# Salvare i dati di pagamento durante un pagamento in-app Salvare i dati di pagamento durante un pagamento nell'app mobile # iOS > This is a iOS for when platform is ios and mobile-ui is payment-element. View the full page at https://docs.stripe.com/payments/mobile/save-during-payment?platform=ios&mobile-ui=payment-element. Usa l’[API Payment Intents](https://docs.stripe.com/api/payment_intents.md) per salvare i dati di pagamento da un acquisto. Esistono più casi d’uso: - Addebita un pagamento a un cliente per un ordine di e-commerce e memorizza i dati per gli acquisti futuri. - Avvia il primo di una serie di pagamenti ricorrenti. - Addebita un deposito e memorizza i dati per addebitare l’intero importo in seguito. > #### Transazioni con carta presente > > Le transazioni con carta presente, come i pagamenti tramite Stripe Terminal, utilizzano una procedura diversa per salvare il metodo di pagamento. Per i dettagli, consulta [la documentazione di Terminal](https://docs.stripe.com/terminal/features/saving-payment-details/save-after-payment.md). ## Conformità Sei responsabile del rispetto di tutte le leggi, i regolamenti e le norme di rete applicabili quando salvi i dettagli di pagamento di un cliente per un utilizzo futuro, ad esempio per mostrargli il metodo di pagamento nel flusso di checkout per un acquisto futuro o per addebitargli un importo quando non sta utilizzando attivamente il tuo sito web o la tua app. Prima di salvare o addebitare il metodo di pagamento di un cliente, assicurati di: - Aggiungere al tuo sito web o alla tua app delle clausole che specificano come intendi salvare i dettagli relativi ai metodi di pagamento, ad esempio: - L’accordo del cliente che ti consente di avviare un pagamento o una serie di pagamenti per suo conto per transazioni specifiche. - La tempistica e la frequenza dei pagamenti previste (ad esempio, se gli addebiti sono per rate programmate, pagamenti di abbonamenti o ricariche non programmate). - Il modo in cui determini l’importo del pagamento. - I tuoi termini di cancellazione, se la modalità di pagamento è per un servizio in abbonamento. - Utilizza un metodo di pagamento salvato solo per lo scopo indicato nei tuoi termini. - Ottieni il consenso esplicito del cliente per questo specifico utilizzo. Ad esempio, includi una casella di controllo “Salva il mio metodo di pagamento per il futuro”. - Conserva una copia dell’accordo scritto del cliente con i tuoi termini. ## Configurare Stripe [Lato server] [Lato client] Innanzitutto, hai bisogno di un Stripe account. [Registrati ora](https://dashboard.stripe.com/register). ### Lato server Per questa integrazione sono necessari endpoint sul server che comunicano con l’API Stripe. Utilizza le nostre librerie ufficiali per accedere all’API Stripe dal tuo server: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Lato client L’[SDK per iOS di Stripe](https://github.com/stripe/stripe-ios) è open source, [completamente documentato](https://stripe.dev/stripe-ios/index.html) e compatibile con le app che supportano iOS 13 o versioni successive. #### Swift Package Manager Per installare l’SDK, segui questi passaggi: 1. In Xcode, seleziona **File** > **Aggiungi dipendenze pacchetto…** e inserisci `https://github.com/stripe/stripe-ios-spm` come URL repository. 1. Seleziona il numero dell’ultima versione dalla nostra [pagina delle release](https://github.com/stripe/stripe-ios/releases). 1. Aggiungi il prodotto **StripePaymentSheet** al [target della tua app](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app). #### CocoaPods 1. Se non l’hai ancora fatto, installa la versione più recente di [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Se non hai un [Podfile](https://guides.cocoapods.org/syntax/podfile.html), esegui il seguente comando per crearne uno: ```bash pod init ``` 1. Aggiungi questa riga al tuo `Podfile`: ```podfile pod 'StripePaymentSheet' ``` 1. Esegui il seguente comando: ```bash pod install ``` 1. Ricordati di utilizzare d’ora in poi il file `.xcworkspace` per aprire il progetto in Xcode, anziché il file `.xcodeproj` file. 1. In futuro, per eseguire l’aggiornamento alla versione più recente dell’SDK, esegui questo comando: ```bash pod update StripePaymentSheet ``` #### Carthage 1. Se non l’hai ancora fatto, installa la versione più recente di [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Aggiungi questa riga al tuo `Cartfile`: ```cartfile github "stripe/stripe-ios" ``` 1. Segui le [istruzioni per l’installazione di Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Assicurati di integrare tutti i framework necessari elencati [qui](https://github.com/stripe/stripe-ios/tree/master/StripePaymentSheet/README.md#manual-linking). 1. In futuro, per eseguire l’aggiornamento alla versione più recente del nostro SDK, esegui il seguente comando: ```bash carthage update stripe-ios --platform ios ``` #### Framework manuale 1. Vai alla [pagina delle versioni di GitHub](https://github.com/stripe/stripe-ios/releases/latest) e scarica e decomprimi **Stripe.xcframework.zip**. 1. Trascina **StripePaymentSheet.xcframework** nella sezione **Embedded Binaries** (File binari incorporati) delle impostazioni **General** (Generali) nel tuo progetto Xcode. Assicurati che sia selezionato **Copy items if needed** (Copia elementi se necessario). 1. Ripeti il passaggio 2 per tutti i framework necessari elencati [qui](https://github.com/stripe/stripe-ios/tree/master/StripePaymentSheet/README.md#manual-linking). 1. In futuro, per eseguire l’aggiornamento alla versione più recente del nostro SDK, ripeti i passaggi 1-3. > Per ulteriori informazioni sulla versione più recente e su quelle precedenti dell’SDK, consulta la pagina [Versioni](https://github.com/stripe/stripe-ios/releases) su GitHub. Per ricevere notifiche quando viene pubblicata una nuova versione, [guarda le versioni](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) del repository. ## Abilitare metodi di pagamento I pagamenti con carta sono abilitati per impostazione predefinita. Visualizza le [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods) e abilita i metodi di pagamento che vuoi accettare. ## Aggiungi un endpoint [Lato server] > #### Nota > > Per visualizzare il PaymentSheet prima di creare un PaymentIntent, consulta [Raccogliere i dati di pagamento prima di creare un intento](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment). Questa integrazione utilizza tre oggetti dell’API Stripe: 1. [PaymentIntent](https://docs.stripe.com/api/payment_intents.md): Stripe lo utilizza per rappresentare la tua intenzione di riscuotere un pagamento da un cliente, monitorando i tentativi di addebito e le modifiche dello stato del pagamento durante la procedura. 1. Un [account configurato dal cliente](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) o un oggetto [Customer](https://docs.stripe.com/api/customers.md): per impostare un metodo di pagamento per pagamenti futuri, è necessario associarlo a un cliente. Crea un oggetto che rappresenti il tuo cliente quando crea un account presso la tua attività. Se il cliente effettua un pagamento come ospite, è possibile creare un oggetto `Account` o `Customer` prima del pagamento e associarlo in un secondo momento alla propria rappresentazione interna dell’account del cliente. 1. [CustomerSession](https://docs.stripe.com/api/customer_sessions.md): le informazioni relative all’oggetto che rappresenta il cliente sono sensibili e non possono essere recuperate direttamente da un’app. Una `CustomerSession` concede all’SDK un accesso temporaneo e limitato ad `Account` o `Cliente` e offre ulteriori opzioni di configurazione. Consulta l’elenco completo delle [opzioni di configurazione](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components). Per motivi di sicurezza, la tua app non può creare questi oggetti. Aggiungi invece un endpoint sul tuo server per: 1. Recupera `Account` o `Customer` o ne crea uno nuovo. 1. Crea una [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) per `Account` o `Customer`. 1. Crea un `PaymentIntent` con [importo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount), [valuta](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency), [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage), e [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) o [cliente](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer). 1. Restituisce *chiave privata client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) del `PaymentIntent`,`client_secret` di `CustomerSession`, ID di `Account` o `Customer`, e [chiave pubblicabile](https://dashboard.stripe.com/apikeys) alla tua app. > Payment Element per dispositivi mobili supporta solo `setup_future_usage` con conti bancari degli Stati Uniti e carte di credito. I metodi di pagamento mostrati ai clienti durante il completamento della transazione sono inclusi anche nel PaymentIntent. Puoi consentire a Stripe di acquisire i metodi di pagamento dalle impostazioni della Dashboard oppure puoi elencarli manualmente. Indipendentemente dall’opzione che sceglierai, ricorda che la valuta specificata nel PaymentIntent filtra il metodo di pagamento mostrato al cliente. Ad esempio, se specifichi `eur` nel PaymentIntent e hai abilitato OXXO nella Dashboard, il cliente non vedrà OXXO perché questo metodo non supporta i pagamenti in `eur`. A meno che la tua integrazione non richieda un’opzione con codice per offrire i metodi di pagamento, Stripe consiglia l’opzione automatica. Ciò è dovuto al fatto che Stripe valuta le limitazioni dei metodi di pagamento, la valuta e altri parametri per determinare l’elenco dei metodi di pagamento accettati. I metodi di pagamento che migliorano la conversione e che sono più pertinenti alla valuta e alla posizione del cliente hanno la priorità. #### Gestire i metodi di pagamento dalla Dashboard Puoi gestire i metodi di pagamento dalla [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe determina la restituzione dei metodi di pagamento idonei in base a fattori quali l’importo della transazione, la valuta e il flusso di pagamento. Il PaymentIntent viene creato utilizzando i metodi di pagamento configurati nella Dashboard. Se non desideri utilizzare la Dashboard o se preferisci specificare manualmente i metodi di pagamento, puoi elencarli utilizzando l’attributo `payment_method_types`. #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Elencare manualmente i metodi di pagamento #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` > Ogni metodo di pagamento deve accettare la valuta specificata nel PaymentIntent e la tua attività deve avere la sede in uno dei Paesi accettati dal metodo di pagamento. Per ulteriori informazioni sulle funzionalità supportate, consulta la pagina dedicata alle [opzioni di integrazione dei metodi di pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md). ## Raccogliere i dati di pagamento [Lato client] Per visualizzare Payment Element per dispositivi mobili nella schermata di pagamento, assicurati di: - Mostrare i prodotti che il cliente sta acquistando insieme all’importo totale - Utilizza [Address Element](https://docs.stripe.com/elements/address-element.md?platform=ios) per raccogliere dal cliente tutti i dati di spedizione richiesti - Aggiungere un pulsante di pagamento per visualizzare l’interfaccia utente di Stripe #### UIKit Nella schermata di checkout della tua app, recupera la chiave privata client PaymentIntent, il segreto client CustomerSession, l’ID cliente e la chiave pubblicabile dall’endpoint creato nel passaggio precedente. Utilizza `STPAPIClient.shared` per impostare la tua chiave pubblicabile e inizializzare [PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html). #### iOS (Swift) ```swift import UIKit@_spi(CustomerSessionBetaAccess) import StripePaymentSheet class CheckoutViewController: UIViewController { @IBOutlet weak var checkoutButton: UIButton! var paymentSheet: PaymentSheet? let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint override func viewDidLoad() { super.viewDidLoad() checkoutButton.addTarget(self, action: #selector(didTapCheckoutButton), for: .touchUpInside) checkoutButton.isEnabled = false // MARK: Fetch the PaymentIntent client secret, CustomerSession client secret, Customer ID, and publishable key var request = URLRequest(url: backendCheckoutUrl) request.httpMethod = "POST" let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in guard let data = data, let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any], let customerId = json["customer"] as? String, let customerSessionClientSecret = json["customerSessionClientSecret"] as? String, let paymentIntentClientSecret = json["paymentIntent"] as? String, let publishableKey = json["publishableKey"] as? String, let self = self else { // Handle error return } STPAPIClient.shared.publishableKey = publishableKey// MARK: Create a PaymentSheet instance var configuration = PaymentSheet.Configuration() configuration.merchantDisplayName = "Example, Inc." configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret) // Set `allowsDelayedPaymentMethods` to true if your business handles // delayed notification payment methods like US bank accounts. configuration.allowsDelayedPaymentMethods = true self.paymentSheet = PaymentSheet(paymentIntentClientSecret:paymentIntentClientSecret, configuration: configuration) DispatchQueue.main.async { self.checkoutButton.isEnabled = true } }) task.resume() } } ``` Quando il cliente tocca il pulsante **Checkout**, chiama `present` per aprire il PaymentSheet. Dopo che il cliente ha completato il pagamento, Stripe chiude il PaymentSheet e chiama il blocco di completamento con [PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html). #### iOS (Swift) ```swift @objc func didTapCheckoutButton() { // MARK: Start the checkout process paymentSheet?.present(from: self) { paymentResult in // MARK: Handle the payment result switch paymentResult { case .completed: print("Your order is confirmed") case .canceled: print("Canceled!") case .failed(let error): print("Payment failed: \(error)") } } } ``` #### SwiftUI Crea un modello `ObservableObject` per la tua schermata di pagamento. Questo modello pubblica un [PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html) e un [PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html). ```swift import StripePaymentSheet import SwiftUI class CheckoutViewModel: ObservableObject { let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint @Published var paymentSheet: PaymentSheet? @Published var paymentResult: PaymentSheetResult? } ``` Recupera il segreto client PaymentIntent, la chiave privata client CustomerSession, l’ID cliente e la chiave pubblicabile dall’endpoint creato nel passaggio precedente. Utilizza `STPAPIClient.shared` per impostare la chiave pubblicabile e inizializzare [PaymentSheet](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet.html). ```swift @_spi(CustomerSessionBetaAccess) import StripePaymentSheet import SwiftUI class CheckoutViewModel: ObservableObject { let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint @Published var paymentSheet: PaymentSheet? @Published var paymentResult: PaymentSheetResult? func preparePaymentSheet() { // MARK: Fetch thePaymentIntent and Customer information from the backend var request = URLRequest(url: backendCheckoutUrl) request.httpMethod = "POST" let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in guard let data = data, let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any], let customerId = json["customer"] as? String, let customerSessionClientSecret = json["customerSessionClientSecret"] as? String, letpaymentIntentClientSecret = json["paymentIntent"] as? String, let publishableKey = json["publishableKey"] as? String, let self = self else { // Handle error return } STPAPIClient.shared.publishableKey = publishableKey// MARK: Create a PaymentSheet instance var configuration = PaymentSheet.Configuration() configuration.merchantDisplayName = "Example, Inc." configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret) // Set `allowsDelayedPaymentMethods` to true if your business handles // delayed notification payment methods like US bank accounts. configuration.allowsDelayedPaymentMethods = true DispatchQueue.main.async { self.paymentSheet = PaymentSheet(paymentIntentClientSecret:paymentIntentClientSecret, configuration: configuration) } }) task.resume() } } struct CheckoutView: View { @ObservedObject var model = CheckoutViewModel() var body: some View { VStack { if model.paymentSheet != nil { Text("Ready to pay.") } else { Text("Loading…") } }.onAppear { model.preparePaymentSheet() } } } ``` Aggiungi un [PaymentSheet.PaymentButton](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/PaymentButton.html) alla tua `View`. Si comporta in modo simile a un `Button` di SwiftUI, che ti consente di personalizzarlo aggiungendo una `View`. Quando tocchi il pulsante, viene visualizzato il PaymentSheet. Una volta completato il pagamento, Stripe chiude il PaymentSheet e chiama il gestore `onCompletion` con un oggetto [PaymentSheetResult](https://stripe.dev/stripe-ios/stripe-paymentsheet/Enums/PaymentSheetResult.html). ```swift @_spi(CustomerSessionBetaAccess) import StripePaymentSheet import SwiftUI class CheckoutViewModel: ObservableObject { let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")! // Your backend endpoint @Published var paymentSheet: PaymentSheet? @Published var paymentResult: PaymentSheetResult? func preparePaymentSheet() { // MARK: Fetch the PaymentIntent and Customer information from the backend var request = URLRequest(url: backendCheckoutUrl) request.httpMethod = "POST" let task = URLSession.shared.dataTask(with: request, completionHandler: { [weak self] (data, response, error) in guard let data = data, let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String : Any], let customerId = json["customer"] as? String, let customerSessionClientSecret = json["customerSessionClientSecret"] as? String, let paymentIntentClientSecret = json["paymentIntent"] as? String, let publishableKey = json["publishableKey"] as? String, let self = self else { // Handle error return } STPAPIClient.shared.publishableKey = publishableKey // MARK: Create a PaymentSheet instance var configuration = PaymentSheet.Configuration() configuration.merchantDisplayName = "Example, Inc." configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret) // Set `allowsDelayedPaymentMethods` to true if your business can handle payment methods // that complete payment after a delay, like SEPA Debit and Sofort. configuration.allowsDelayedPaymentMethods = true DispatchQueue.main.async { self.paymentSheet = PaymentSheet(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration) } }) task.resume() } func onPaymentCompletion(result: PaymentSheetResult) { self.paymentResult = result } } struct CheckoutView: View { @ObservedObject var model = CheckoutViewModel() var body: some View { VStack {if let paymentSheet = model.paymentSheet { PaymentSheet.PaymentButton( paymentSheet: paymentSheet, onCompletion: model.onPaymentCompletion ) { Text("Buy") } } else { Text("Loading…") }if let result = model.paymentResult { switch result { case .completed: Text("Payment complete") case .failed(let error): Text("Payment failed: \(error.localizedDescription)") case .canceled: Text("Payment canceled.") } } }.onAppear { model.preparePaymentSheet() } } } ``` Se `PaymentSheetResult` risulta `.completed`, informa l’utente (ad esempio, visualizzando una schermata di conferma d’ordine). Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento. ## Configurare un URL di ritorno [Lato client] Il cliente potrebbe uscire dalla tua app per autenticarsi (ad es. in Safari o nell’app della banca). Per consentirgli di tornare automaticamente alla tua app dopo l’autenticazione, devi [configurare uno schema URL personalizzato](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) e impostare la classe AppDelegate per l’inoltro di URL all’SDK Stripe. Stripe non supporta i [link universali](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content). #### SceneDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func scene(_ scene: UIScene, openURLContexts URLContexts: Set) { guard let url = URLContexts.first?.url else { return } let stripeHandled = StripeAPI.handleURLCallback(with: url) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } ``` #### AppDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool { let stripeHandled = StripeAPI.handleURLCallback(with: url) if (stripeHandled) { return true } else { // This was not a Stripe url – handle the URL normally as you would } return false } ``` #### SwiftUI #### Swift ```swift @main struct MyApp: App { var body: some Scene { WindowGroup { Text("Hello, world!").onOpenURL { incomingURL in let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } } } } ``` Devi inoltre impostare il [returnURL](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV9returnURLSSSgvp) nel tuo oggetto [PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html) sull’URL della tua app. ```swift var configuration = PaymentSheet.Configuration() configuration.returnURL = "your-app://stripe-redirect" ``` ## Gestire gli eventi successivi al pagamento [Lato server] Stripe invia un evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) quando il pagamento viene completato. Utilizza lo [strumento webhook Dashboard](https://dashboard.stripe.com/webhooks) o segui la [guida ai webhook](https://docs.stripe.com/webhooks/quickstart.md) per ricevere questi eventi ed eseguire azioni come l’invio di una email per la conferma di un ordine al cliente, la registrazione della vendita in un database o l’avvio del flusso di lavoro per una spedizione. Ascolta questi eventi invece di attendere una chiamata di ritorno dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione della chiamata di ritorno e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente di accettare [diversi tipi di modalità di pagamento](https://stripe.com/payments/payment-methods-guide) con una sola integrazione. Oltre alla gestione dell’evento `payment_intent.succeeded`, è consigliabile gestire altri eventi durante la riscossione di pagamenti tramite Payment Element: | Evento | Descrizione | Azione | | ------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded) | Inviato quando un cliente ha disposto un pagamento con esito positivo. | Invia al cliente la conferma di un ordine ed *evade* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) l’ordine. | | [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing) | Inviato quando un cliente ha correttamente disposto un pagamento che non è stato ancora completato. Questo evento viene di solito inviato quando il cliente dispone un addebito bancario. Sarà poi seguito da un evento `payment_intent.succeeded` o da un evento `payment_intent.payment_failed`. | Invia al cliente la conferma di un ordine che indica il pagamento in sospeso. Per i beni digitali, potresti voler evadere l’ordine senza attendere il completamento del pagamento. | | [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | Inviato quando il cliente ha tentato un pagamento che non è andato a buon fine. | Se un pagamento passa da `processing` a `payment_failed`, offri al cliente un altro tentativo di pagamento. | ## Addebitare in un secondo momento un importo sul PaymentMethod salvato [Lato server] > #### Conformità > > Quando salvi i dati di pagamento di un cliente, sei responsabile della conformità a tutte le leggi, le normative e le regole del circuito applicabili. Quando presenti al cliente finale i metodi di pagamento utilizzati in passato per acquisti futuri, accertati di elencare i metodi di pagamento per i quali hai raccolto il consenso a salvare i dati del metodo di pagamento per gli usi futuri specifici. Per differenziare i metodi di pagamento legati ai clienti che possono o non possono essere presentati al cliente finale come metodo di pagamento salvato per acquisti futuri, utilizza il parametro [allow_redisplay](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-allow_redisplay). Per individuare il metodo di pagamento da addebitare, elenca i metodi di pagamento associati al tuo cliente. In questo esempio vengono elencate le carte, ma puoi indicare qualsiasi [tipo](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-type) supportato. > #### Utilizza l'API Accounts v2 per rappresentare i clienti > > The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a [specify a preview version](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in your code. > > To request access to the Accounts v2 preview, > > Nella maggior parte dei casi d’uso, consigliamo di [rappresentare i clienti come oggetti Account configurati dall’utente,](https://docs.stripe.com/connect/use-accounts-as-customers.md) anziché utilizzare oggetti [Customer](https://docs.stripe.com/api/customers.md). #### Account v2 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d type=card ``` #### Clienti v1 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d type=card ``` Quando è tutto pronto per l’addebito al cliente *off-session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information), utilizza l’ID del cliente e l’ID del `PaymentMethod` per creare un `PaymentIntent` specificando l’importo e la valuta del pagamento. Imposta alcuni altri parametri per effettuare il pagamento off-session: - Impostare [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) a `true` per indicare che il cliente non è nel flusso di pagamento durante un tentativo di pagamento e non può soddisfare una richiesta di autenticazione effettuata da un partner, come una società emittente della carta, una banca o altro istituto di pagamento. Se, durante il flusso di pagamento, un partner richiede l’autenticazione, Stripe richiede le esenzioni utilizzando le informazioni sul cliente ricavate da una transazione precedente *all’interno della sessione* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method). Se le condizioni per l’esenzione non sono soddisfatte, il `PaymentIntent` potrebbe generare un errore. - Imposta il valore di [conferma](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) della proprietà `PaymentIntent` su true, per far sì che la conferma avvenga immediatamente quando crei il `PaymentIntent`. - Imposta [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) sull’ID del `PaymentMethod`. - SA seconda di come rappresenti i clienti nella tua integrazione, imposta [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) sull’ID dell’`Account` configurato dal cliente o [cliente](https://docs.stripe.com/api.md#create_payment_intent-customer) sull’ID del `Customer`. #### Account v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` #### Clienti v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer={{CUSTOMER_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` ## Testare l'integrazione #### Carte | Modalità di pagamento | Scenario | Come eseguire il test | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | | Carta di credito | La configurazione della carta ha esito positivo e non richiede l’*autenticazione* (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). | Compila il modulo per la carta di credito usando il numero di carta di credito `4242 4242 4242 4242` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta richiede l’autenticazione per la configurazione iniziale, poi ha esito positivo per i pagamenti successivi. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0025 0000 3155` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta richiede l’autenticazione per la configurazione iniziale e per i pagamenti successivi. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0027 6000 3184` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta viene rifiutata durante la configurazione. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0000 0000 9995` con qualsiasi scadenza, CVC e codice postale. | ## Optional: Abilitare Apple Pay > Se nella tua schermata di pagamento è presente un **pulsante Apple Pay** dedicato, segui le istruzioni indicate nella [guida di Apple Pay](https://docs.stripe.com/apple-pay.md#present-payment-sheet) e usa `ApplePayContext` per riscuotere il pagamento tramite il pulsante Apple Pay. Puoi usare `PaymentSheet` per gestire altri metodi di pagamento. ### Registra un nuovo ID esercente Apple Ottieni un ID esercente Apple [effettuando la registrazione di un nuovo identificativo](https://developer.apple.com/account/resources/identifiers/add/merchant) sul sito web degli sviluppatori Apple. Compila il modulo con una descrizione e un identificativo. La descrizione è un promemoria per te e potrai modificarla in futuro. Stripe consiglia di utilizzare il nome dell’app come identificativo (ad esempio, `merchant.com.{{YOUR_APP_NAME}}`). ### Crea un nuovo certificato di Apple Pay Crea un certificato per la tua app per crittografare i dati di pagamento. Vai su [Impostazioni certificato iOS](https://dashboard.stripe.com/settings/ios_certificates) nella Dashboard, fai clic su **Aggiungi nuova applicazione** e segui la guida. Scarica un file con richiesta di firma certificato (CSR) per ottenere da Apple un certificato sicuro che ti consentirà di utilizzare Apple Pay. Un file CSR deve essere utilizzato per emettere un solo certificato. Se cambi il tuo ID esercente Apple, devi andare su [Impostazioni certificato iOS](https://dashboard.stripe.com/settings/ios_certificates) nella Dashboard per ottenere un nuovo CSR e un nuovo certificato. ### Effettua l’integrazione con Xcode Aggiungi la funzionalità Apple Pay alla tua app. In Xcode, apri le impostazioni di progetto, fai clic nella scheda **Signing & Capabilities** (Firma e funzionalità), poi aggiungi la funzionalità **Apple Pay**. A questo punto il sistema potrebbe chiederti di effettuare l’accesso al tuo account di sviluppatore. Seleziona l’ID esercente che hai creato e la tua app sarà pronta ad accettare Apple Pay. ![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png) Abilita la funzionalità Apple Pay in Xcode ### Aggiungi Apple Pay #### Pagamento una tantum Per aggiungere Apple Pay a PaymentSheet, imposta [applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp) dopo l’inizializzazione di `PaymentSheet.Configuration` con il tuo ID esercente Apple e il [codice Paese della tua attività](https://dashboard.stripe.com/settings/account). #### iOS (Swift) ```swift var configuration = PaymentSheet.Configuration() configuration.applePay = .init( merchantId: "merchant.com.your_app_name", merchantCountryCode: "US" ) ``` #### Pagamenti ricorrenti Per aggiungere Apple Pay a PaymentSheet, imposta [applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp) dopo l’inizializzazione di `PaymentSheet.Configuration` con il tuo ID esercente Apple e il [codice Paese della tua attività](https://dashboard.stripe.com/settings/account). Secondo le [linee guida di Apple](https://developer.apple.com/design/human-interface-guidelines/apple-pay#Supporting-subscriptions) per i pagamenti ricorrenti, devi impostare anche altri attributi in `PKPaymentRequest`. Aggiungi un gestore in [ApplePayConfiguration.paymentRequestHandlers](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/paymentrequesthandler) per configurare [PKPaymentRequest.paymentSummaryItems](https://developer.apple.com/documentation/passkit/pkpaymentrequest/1619231-paymentsummaryitems) con l’importo che intendi addebitare (ad esempio, 9,95 USD al mese). Puoi anche adottare i [token dell’esercente](https://developer.apple.com/apple-pay/merchant-tokens/) impostando le proprietà `recurringPaymentRequest` o `automaticReloadPaymentRequest` su `PKPaymentRequest`. Per ulteriori informazioni su come utilizzare i pagamenti ricorrenti con Apple Pay, consulta [la documentazione di PassKit di Apple](https://developer.apple.com/documentation/passkit/pkpaymentrequest). #### iOS (Swift) ```swift let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers( paymentRequestHandler: { request in // PKRecurringPaymentSummaryItem is available on iOS 15 or later if #available(iOS 15.0, *) { let billing = PKRecurringPaymentSummaryItem(label: "My Subscription", amount: NSDecimalNumber(string: "59.99")) // Payment starts today billing.startDate = Date() // Payment ends in one year billing.endDate = Date().addingTimeInterval(60 * 60 * 24 * 365) // Pay once a month. billing.intervalUnit = .month billing.intervalCount = 1 // recurringPaymentRequest is only available on iOS 16 or later if #available(iOS 16.0, *) { request.recurringPaymentRequest = PKRecurringPaymentRequest(paymentDescription: "Recurring", regularBilling: billing, managementURL: URL(string: "https://my-backend.example.com/customer-portal")!) request.recurringPaymentRequest?.billingAgreement = "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'" } request.paymentSummaryItems = [billing] request.currencyCode = "USD" } else { // On older iOS versions, set alternative summary items. request.paymentSummaryItems = [PKPaymentSummaryItem(label: "Monthly plan starting July 1, 2022", amount: NSDecimalNumber(string: "59.99"), type: .final)] } return request } ) var configuration = PaymentSheet.Configuration() configuration.applePay = .init(merchantId: "merchant.com.your_app_name", merchantCountryCode: "US", customHandlers: customHandlers) ``` ### Monitoraggio degli ordini Per aggiungere informazioni sulla [tracciabilità degli ordini](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking) in iOS 16 o versioni successive, configura un [authorizationResultHandler](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/authorizationresulthandler) nel tuo `PaymentSheet.ApplePayConfiguration.Handlers`. Stripe chiama la tua implementazione dopo che il pagamento è stato completato, ma prima che iOS chiuda il foglio di Apple Pay. Nell’implementazione dell’`authorizationResultHandler`, recupera i dettagli dell’ordine completato dal server. Aggiungi i dettagli al [PKPaymentAuthorizationResult](https://developer.apple.com/documentation/passkit/pkpaymentauthorizationresult) fornito e restituisci il risultato modificato. Per ulteriori informazioni sul monitoraggio degli ordini, consulta la [Documentazione sugli ordini in Apple Wallet](https://developer.apple.com/documentation/walletorders). #### iOS (Swift) ```swift let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers( authorizationResultHandler: { result in do { // Fetch the order details from your service let myOrderDetails = try await MyAPIClient.shared.fetchOrderDetails(orderID: orderID) result.orderDetails = PKPaymentOrderDetails( orderTypeIdentifier: myOrderDetails.orderTypeIdentifier, // "com.myapp.order" orderIdentifier: myOrderDetails.orderIdentifier, // "ABC123-AAAA-1111" webServiceURL: myOrderDetails.webServiceURL, // "https://my-backend.example.com/apple-order-tracking-backend" authenticationToken: myOrderDetails.authenticationToken) // "abc123" // Return your modified PKPaymentAuthorizationResult return result } catch { return PKPaymentAuthorizationResult(status: .failure, errors: [error]) } } ) var configuration = PaymentSheet.Configuration() configuration.applePay = .init(merchantId: "merchant.com.your_app_name", merchantCountryCode: "US", customHandlers: customHandlers) ``` ## Abilitare la scansione delle carte Per abilitare il supporto alla scansione delle carte per iOS, imposta `NSCameraUsageDescription` (**Privacy - Descrizione dell’utilizzo della fotocamera**) nel file `Info.plist` della tua applicazione e fornisci un motivo per l’accesso alla fotocamera (ad esempio, “Per scansionare le carte”). ## Optional: Personalizzare la scheda Tutte le personalizzazioni vengono configurate utilizzando l’oggetto [PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html). ### Aspetto Personalizza i colori, i caratteri e molto altro ancora in base all’aspetto della tua app utilizzando l’[API Appearance](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=ios). ### Layout del metodo di pagamento Configura il layout dei metodi di pagamento nel foglio utilizzando [paymentMethodLayout](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/configuration-swift.struct/paymentmethodlayout). Puoi visualizzarli orizzontalmente, verticalmente o lasciare che Stripe ne ottimizzi il layout automaticamente. ![](https://b.stripecdn.com/docs-statics-srv/assets/ios-mpe-payment-method-layouts.9d0513e2fcec5660378ba1824d952054.png) #### Swift ```swift var configuration = PaymentSheet.Configuration() configuration.paymentMethodLayout = .automatic ``` ### Acquisire gli indirizzi degli utenti Acquisisci gli indirizzi di spedizione o fatturazione locali e internazionali dai tuoi clienti utilizzando il componente [Address Element](https://docs.stripe.com/elements/address-element.md?platform=ios). ### Nome visualizzato dell’esercente Specifica un nome dell’attività per il cliente impostando [merchantDisplayName](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV19merchantDisplayNameSSvp). Per impostazione predefinita, viene utilizzato il nome della tua app. #### Swift ```swift var configuration = PaymentSheet.Configuration() configuration.merchantDisplayName = "My app, Inc." ``` ### Modalità scura Il `PaymentSheet` si adatta automaticamente alle impostazioni di visualizzazione del sistema dell’utente (modalità chiara o scura). Se la tua app non supporta la modalità scura, puoi impostare lo [stile](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV5styleAC18UserInterfaceStyleOvp) sulla modalità `alwaysLight` o `alwaysDark`. ```swift var configuration = PaymentSheet.Configuration() configuration.style = .alwaysLight ``` ### Dettagli di addebito predefiniti Per impostare i valori predefiniti per i dettagli di addebito raccolti nella scheda di pagamento, configura la proprietà `defaultBillingDetails`. `PaymentSheet` precompila i campi della scheda con i valori che fornisci. ```swift var configuration = PaymentSheet.Configuration() configuration.defaultBillingDetails.address.country = "US" configuration.defaultBillingDetails.email = "foo@bar.com" ``` ### Raccolta dei dati per gli addebiti Utilizza `billingDetailsCollectionConfiguration` per specificare la modalità di raccolta dei dati per gli addebiti nel Payment Sheet. Puoi acquisire il nome, l’indirizzo email, il numero di telefono e l’indirizzo del cliente. Se vuoi raccogliere solo i dati di fatturazione richiesti dal metodo di pagamento, imposta `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod`su true. In tal caso, i `PaymentSheet.Configuration.defaultBillingDetails` vengono impostati come [dati di fatturazione](https://docs.stripe.com/api/payment_methods/object.md?lang=node#payment_method_object-billing_details) del metodo di pagamento. Se desideri raccogliere ulteriori dettagli di fatturazione che non sono necessariamente richiesti dalla modalità di pagamento, imposta `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` su false. In tal caso, i dettagli di fatturazione raccolti tramite il `PaymentSheet` vengono impostati come dettagli di fatturazione della modalità di pagamento. ```swift var configuration = PaymentSheet.Configuration() configuration.defaultBillingDetails.email = "foo@bar.com" configuration.billingDetailsCollectionConfiguration.name = .always configuration.billingDetailsCollectionConfiguration.email = .never configuration.billingDetailsCollectionConfiguration.address = .full configuration.billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod = true ``` > Rivolgiti al tuo consulente legale per sapere quali sono le leggi applicabili alla raccolta di informazioni. Richiedi i numeri di telefono solo se necessari per la transazione. ## Optional: Completare il pagamento nell'interfaccia utente Puoi visualizzare il Payment Sheet solo per raccogliere i dati relativi alla modalità di pagamento e chiamare una modalità `confirm` in un secondo momento per completare il pagamento nell’interfaccia utente dell’app. Questa opzione è utile se disponi di un pulsante personalizzato per l’acquisto o se occorrono passaggi aggiuntivi dopo che hai acquisito i dati di pagamento. ![](https://b.stripecdn.com/docs-statics-srv/assets/ios-multi-step.cd631ea4f1cd8cf3f39b6b9e1e92b6c5.png) Completare il pagamento nell’interfaccia utente dell’app #### UIKit I seguenti passaggi ti illustrano come completare il pagamento nell’interfaccia utente della tua app. Consulta il nostro esempio di integrazione su [GitHub](https://github.com/stripe/stripe-ios/blob/master/Example/PaymentSheet%20Example/PaymentSheet%20Example/ExampleCustomCheckoutViewController.swift). 1. Innanzitutto, inizializza [PaymentSheet.FlowController](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller) invece di `PaymentSheet` e aggiorna la tua interfaccia utente con la sua proprietà `paymentOption`. Questa proprietà contiene un’immagine e un’etichetta che rappresentano la modalità di pagamento predefinita, inizialmente selezionata dal cliente. ```swift PaymentSheet.FlowController.create(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration) { [weak self] result in switch result { case .failure(let error): print(error) case .success(let paymentSheetFlowController): self?.paymentSheetFlowController = paymentSheetFlowController // Update your UI using paymentSheetFlowController.paymentOption } } ``` 1. Poi chiama `presentPaymentOptions` per raccogliere i dati relativi al pagamento. Al termine, aggiorna di nuovo la tua interfaccia utente con la proprietà `paymentOption`. ```swift paymentSheetFlowController.presentPaymentOptions(from: self) { // Update your UI using paymentSheetFlowController.paymentOption } ``` 1. Infine, chiama `confirm`. ```swift paymentSheetFlowController.confirm(from: self) { paymentResult in // MARK: Handle the payment result switch paymentResult { case .completed: print("Payment complete!") case .canceled: print("Canceled!") case .failed(let error): print(error) } } ``` #### SwiftUI I seguenti passaggi ti illustrano come completare il pagamento nell’interfaccia utente della tua app. Consulta il nostro esempio di integrazione su [GitHub](https://github.com/stripe/stripe-ios/blob/master/Example/PaymentSheet%20Example/PaymentSheet%20Example/ExampleSwiftUICustomPaymentFlow.swift). 1. Innanzitutto, inizializza [PaymentSheet.FlowController](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller) invece di `PaymentSheet`. La sua proprietà `paymentOption` contiene un’immagine e un’etichetta che rappresentano la modalità di pagamento attualmente selezionata dal cliente, che puoi utilizzare nella tua interfaccia utente. ```swift PaymentSheet.FlowController.create(paymentIntentClientSecret: paymentIntentClientSecret, configuration: configuration) { [weak self] result in switch result { case .failure(let error): print(error) case .success(let paymentSheetFlowController): self?.paymentSheetFlowController = paymentSheetFlowController // Use the paymentSheetFlowController.paymentOption properties in your UI myPaymentMethodLabel = paymentSheetFlowController.paymentOption?.label ?? "Select a payment method" myPaymentMethodImage = paymentSheetFlowController.paymentOption?.image ?? UIImage(systemName: "square.and.pencil")! } } ``` 1. Utilizza [PaymentSheet.FlowController.PaymentOptionsButton](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller/paymentoptionsbutton) per includere il pulsante che determina l’apertura della scheda per raccogliere i dati di pagamento. Quando `PaymentSheet.FlowController` chiama l’argomento `onSheetDismissed`, `paymentOption` per l’istanza `PaymentSheet.FlowController` indica il metodo di pagamento selezionato al momento. ```swift PaymentSheet.FlowController.PaymentOptionsButton( paymentSheetFlowController: paymentSheetFlowController, onSheetDismissed: { myPaymentMethodLabel = paymentSheetFlowController.paymentOption?.label ?? "Select a payment method" myPaymentMethodImage = paymentSheetFlowController.paymentOption?.image ?? UIImage(systemName: "square.and.pencil")! }, content: { /* An example button */ HStack { Text(myPaymentMethodLabel) Image(uiImage: myPaymentMethodImage) } } ) ``` 1. Utilizza [PaymentSheet.FlowController.PaymentOptionsButton](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller/paymentoptionsbutton) per includere il pulsante che conferma il pagamento. ```swift PaymentSheet.FlowController.ConfirmButton( paymentSheetFlowController: paymentSheetFlowController, onCompletion: { result in // MARK: Handle the payment result switch result { case .completed: print("Payment complete!") case .canceled: print("Canceled!") case .failed(let error): print(error) } }, content: { /* An example button */ Text("Pay") } ) ``` Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento. # Android > This is a Android for when platform is android and mobile-ui is payment-element. View the full page at https://docs.stripe.com/payments/mobile/save-during-payment?platform=android&mobile-ui=payment-element. Usa l’[API Payment Intents](https://docs.stripe.com/api/payment_intents.md) per salvare i dati di pagamento da un acquisto. Esistono più casi d’uso: - Addebita un pagamento a un cliente per un ordine di e-commerce e memorizza i dati per gli acquisti futuri. - Avvia il primo di una serie di pagamenti ricorrenti. - Addebita un deposito e memorizza i dati per addebitare l’intero importo in seguito. > #### Transazioni con carta presente > > Le transazioni con carta presente, come i pagamenti tramite Stripe Terminal, utilizzano una procedura diversa per salvare il metodo di pagamento. Per i dettagli, consulta [la documentazione di Terminal](https://docs.stripe.com/terminal/features/saving-payment-details/save-after-payment.md). ## Conformità Sei responsabile del rispetto di tutte le leggi, i regolamenti e le norme di rete applicabili quando salvi i dettagli di pagamento di un cliente per un utilizzo futuro, ad esempio per mostrargli il metodo di pagamento nel flusso di checkout per un acquisto futuro o per addebitargli un importo quando non sta utilizzando attivamente il tuo sito web o la tua app. Prima di salvare o addebitare il metodo di pagamento di un cliente, assicurati di: - Aggiungere al tuo sito web o alla tua app delle clausole che specificano come intendi salvare i dettagli relativi ai metodi di pagamento, ad esempio: - L’accordo del cliente che ti consente di avviare un pagamento o una serie di pagamenti per suo conto per transazioni specifiche. - La tempistica e la frequenza dei pagamenti previste (ad esempio, se gli addebiti sono per rate programmate, pagamenti di abbonamenti o ricariche non programmate). - Il modo in cui determini l’importo del pagamento. - I tuoi termini di cancellazione, se la modalità di pagamento è per un servizio in abbonamento. - Utilizza un metodo di pagamento salvato solo per lo scopo indicato nei tuoi termini. - Ottieni il consenso esplicito del cliente per questo specifico utilizzo. Ad esempio, includi una casella di controllo “Salva il mio metodo di pagamento per il futuro”. - Conserva una copia dell’accordo scritto del cliente con i tuoi termini. ## Configurare Stripe [Lato server] [Lato client] Innanzitutto, hai bisogno di un Stripe account. [Registrati ora](https://dashboard.stripe.com/register). ### Lato server Per questa integrazione sono necessari endpoint sul server che comunicano con l’API Stripe. Utilizza le librerie ufficiali per accedere all’API Stripe dal tuo server: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Lato client L’[SDK per Android di Stripe](https://github.com/stripe/stripe-android) è open source e [completamente documentato](https://stripe.dev/stripe-android/). Per installare l’SDK, aggiungi `stripe-android` al blocco `dependencies` del tuo file [app/build.gradle](https://developer.android.com/studio/build/dependencies): #### Kotlin ```kotlin plugins { id("com.android.application") } android { ... } dependencies { // ... // Stripe Android SDK implementation("com.stripe:stripe-android:23.3.0") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.3.0") } ``` > Per ulteriori informazioni sulla versione più recente e su quelle precedenti dell’SDK, consulta la pagina [Releases](https://github.com/stripe/stripe-android/releases) su GitHub. Per ricevere una notifica quando viene pubblicata una nuova versione, [imposta il controllo delle versioni per il repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). ## Abilitare metodi di pagamento I pagamenti con carta sono abilitati per impostazione predefinita. Visualizza le [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods) e abilita i metodi di pagamento che vuoi accettare. ## Aggiungi un endpoint [Lato server] > #### Nota > > Per visualizzare il PaymentSheet prima di creare un PaymentIntent, consulta [Raccogliere i dati di pagamento prima di creare un intento](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment). Questa integrazione utilizza tre oggetti dell’API Stripe: 1. [PaymentIntent](https://docs.stripe.com/api/payment_intents.md): Stripe lo utilizza per rappresentare la tua intenzione di riscuotere un pagamento da un cliente, monitorando i tentativi di addebito e le modifiche dello stato del pagamento durante la procedura. 1. Un [account configurato dal cliente](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) o un oggetto [Customer](https://docs.stripe.com/api/customers.md): per impostare un metodo di pagamento per pagamenti futuri, è necessario associarlo a un cliente. Crea un oggetto che rappresenti il tuo cliente quando crea un account presso la tua attività. Se il cliente effettua un pagamento come ospite, è possibile creare un oggetto `Account` o `Customer` prima del pagamento e associarlo in un secondo momento alla propria rappresentazione interna dell’account del cliente. 1. [CustomerSession](https://docs.stripe.com/api/customer_sessions.md): le informazioni relative all’oggetto che rappresenta il cliente sono sensibili e non possono essere recuperate direttamente da un’app. Una `CustomerSession` concede all’SDK un accesso temporaneo e limitato ad `Account` o `Cliente` e offre ulteriori opzioni di configurazione. Consulta l’elenco completo delle [opzioni di configurazione](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components). Per motivi di sicurezza, la tua app non può creare questi oggetti. Aggiungi invece un endpoint sul tuo server per: 1. Recupera `Account` o `Customer` o ne crea uno nuovo. 1. Crea una [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) per `Account` o `Customer`. 1. Crea un `PaymentIntent` con [importo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount), [valuta](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency), [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage), e [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) o [cliente](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer). 1. Restituisce *chiave privata client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) del `PaymentIntent`,`client_secret` di `CustomerSession`, ID di `Account` o `Customer`, e [chiave pubblicabile](https://dashboard.stripe.com/apikeys) alla tua app. > Payment Element per dispositivi mobili supporta solo `setup_future_usage` con conti bancari degli Stati Uniti e carte di credito. I metodi di pagamento mostrati ai clienti durante il completamento della transazione sono inclusi anche nel PaymentIntent. Puoi consentire a Stripe di acquisire i metodi di pagamento dalle impostazioni della Dashboard oppure puoi elencarli manualmente. Indipendentemente dall’opzione che sceglierai, ricorda che la valuta specificata nel PaymentIntent filtra il metodo di pagamento mostrato al cliente. Ad esempio, se specifichi `eur` nel PaymentIntent e hai abilitato OXXO nella Dashboard, il cliente non vedrà OXXO perché questo metodo non supporta i pagamenti in `eur`. A meno che la tua integrazione non richieda un’opzione con codice per offrire i metodi di pagamento, Stripe consiglia l’opzione automatica. Ciò è dovuto al fatto che Stripe valuta le limitazioni dei metodi di pagamento, la valuta e altri parametri per determinare l’elenco dei metodi di pagamento accettati. I metodi di pagamento che migliorano la conversione e che sono più pertinenti alla valuta e alla posizione del cliente hanno la priorità. #### Gestire i metodi di pagamento dalla Dashboard Puoi gestire i metodi di pagamento dalla [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe determina la restituzione dei metodi di pagamento idonei in base a fattori quali l’importo della transazione, la valuta e il flusso di pagamento. Il PaymentIntent viene creato utilizzando i metodi di pagamento configurati nella Dashboard. Se non desideri utilizzare la Dashboard o se preferisci specificare manualmente i metodi di pagamento, puoi elencarli utilizzando l’attributo `payment_method_types`. #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Elencare manualmente i metodi di pagamento #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` > Ogni metodo di pagamento deve accettare la valuta specificata nel PaymentIntent e la tua attività deve avere la sede in uno dei Paesi accettati dal metodo di pagamento. Per ulteriori informazioni sulle funzionalità supportate, consulta la pagina dedicata alle [opzioni di integrazione dei metodi di pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md). ## Raccogliere i dati di pagamento [Lato client] Prima di visualizzare Payment Element per dispositivi mobili, la tua pagina di pagamento dovrebbe: - Mostrare i prodotti acquistati e l’importo totale - Raccogliere tutti i dati di spedizione richiesti utilizzando [Address Element](https://docs.stripe.com/elements/address-element.md?platform=android) - Includere un pulsante di pagamento per visualizzare l’interfaccia utente di Stripe #### Jetpack Componi [Inizializza](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-builder/index.html) un’istanza di `PaymentSheet` in `onCreate` dell’Attività di pagamento, specificando un metodo per gestire il risultato. ```kotlin import androidx.compose.runtime.Composable import androidx.compose.runtime.remember import com.stripe.android.paymentsheet.PaymentSheet import com.stripe.android.paymentsheet.PaymentSheetResult @Composable fun App() { val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build() } private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) { // implemented in the next steps } ``` Quindi, recupera la chiave privata client del PaymentIntent, la chiave privata client Customer Session, l’ID cliente e la chiave pubblicabile dall’endpoint creato nel passaggio precedente. Imposta la chiave pubblicabile utilizzando `PaymentConfiguration` e memorizza le altre per usarle quando visualizzi l’istanza di PaymentSheet. ```kotlin import androidx.compose.runtime.Composable import androidx.compose.runtime.rememberimport androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.compose.ui.platform.LocalContext import com.stripe.android.PaymentConfiguration import com.stripe.android.paymentsheet.PaymentSheet import com.stripe.android.paymentsheet.PaymentSheetResult @Composable fun App() { val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()val context = LocalContext.current var customerConfig by remember { mutableStateOf(null) } varpaymentIntentClientSecret by remember { mutableStateOf(null) } LaunchedEffect(context) { // Make a request to your own server and retrieve payment configurations val networkResult = ... if (networkResult.isSuccess) {paymentIntentClientSecret = networkResult.paymentIntent customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession( id = networkResult.customer, clientSecret = networkResult.customerSessionClientSecret )PaymentConfiguration.init(context, networkResult.publishableKey)} } } private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) { // implemented in the next steps } ``` Quando il cliente tocca il pulsante di pagamento, chiama [presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) per aprire la scheda di pagamento. Non appena il cliente completa il pagamento, la scheda si chiude e [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) viene chiamata con un [PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html). ```kotlin import androidx.compose.material.Button import androidx.compose.material.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import androidx.compose.ui.platform.LocalContext import com.stripe.android.PaymentConfiguration import com.stripe.android.paymentsheet.PaymentSheet import com.stripe.android.paymentsheet.PaymentSheetResult @Composable fun App() { val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build() val context = LocalContext.current var customerConfig by remember { mutableStateOf(null) } var paymentIntentClientSecret by remember { mutableStateOf(null) } LaunchedEffect(context) { // Make a request to your own server and retrieve payment configurations val networkResult = ... if (networkResult.isSuccess) { paymentIntentClientSecret = networkResult.paymentIntent customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession( id = networkResult.customer, clientSecret = networkResult.customerSessionClientSecret ) PaymentConfiguration.init(context, networkResult.publishableKey) } }Button( onClick = { val currentConfig = customerConfig val currentClientSecret =paymentIntentClientSecret if (currentConfig != null && currentClientSecret != null) { presentPaymentSheet(paymentSheet, currentConfig, currentClientSecret) } } ) { Text("Checkout") } }private fun presentPaymentSheet( paymentSheet: PaymentSheet, customerConfig: PaymentSheet.CustomerConfiguration,paymentIntentClientSecret: String ) { paymentSheet.presentWithPaymentIntent(paymentIntentClientSecret, PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name") .customer(customerConfig) // Set `allowsDelayedPaymentMethods` to true if your business handles // delayed notification payment methods like US bank accounts. .allowsDelayedPaymentMethods(true) .build() ) } private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {when(paymentSheetResult) { is PaymentSheetResult.Canceled -> { print("Canceled") } is PaymentSheetResult.Failed -> { print("Error: ${paymentSheetResult.error}") } is PaymentSheetResult.Completed -> { // Display for example, an order confirmation screen print("Completed") } } } ``` #### Viste (classiche) [Inizializza](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#-394860221%2FConstructors%2F2002900378) un’istanza di `PaymentSheet` in `onCreate` dell’Activity del pagamento, specificando un metodo per gestire il risultato. #### Kotlin ```kotlin import com.stripe.android.paymentsheet.PaymentSheet class CheckoutActivity : AppCompatActivity() { lateinit var paymentSheet: PaymentSheet override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this) } fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) { // implemented in the next steps } } ``` Quindi, recupera la chiave privata client del PaymentIntent, la chiave privata client Customer Session, l’ID cliente e la chiave pubblicabile dall’endpoint creato nel passaggio precedente. Imposta la chiave pubblicabile utilizzando `PaymentConfiguration` e memorizza le altre per usarle quando visualizzi l’istanza di PaymentSheet. #### Kotlin ```kotlin import com.stripe.android.paymentsheet.PaymentSheet class CheckoutActivity : AppCompatActivity() { lateinit var paymentSheet: PaymentSheetlateinit var customerConfig: PaymentSheet.CustomerConfiguration lateinit varpaymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this)lifecycleScope.launch { // Make a request to your own server and retrieve payment configurations val networkResult = MyBackend.getPaymentConfig() if (networkResult.isSuccess) {paymentIntentClientSecret = networkResult.paymentIntent customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession( id = networkResult.customer, clientSecret = networkResult.customerSessionClientSecret )PaymentConfiguration.init(context, networkResult.publishableKey)} } } fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) { // implemented in the next steps } } ``` Quando il cliente tocca il pulsante di pagamento, chiama [presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) per aprire la scheda di pagamento. Non appena il cliente completa il pagamento, la scheda si chiude e [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) viene chiamata con un [PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html). #### Kotlin ```kotlin // ... class CheckoutActivity : AppCompatActivity() { lateinit var paymentSheet: PaymentSheet lateinit var customerConfig: PaymentSheet.CustomerConfiguration lateinit var paymentIntentClientSecret: String // ...fun presentPaymentSheet() { paymentSheet.presentWithPaymentIntent(paymentIntentClientSecret, PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name") .customer(customerConfig) // Set `allowsDelayedPaymentMethods` to true if your business handles // delayed notification payment methods like US bank accounts. .allowsDelayedPaymentMethods(true) .build() ) } fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {when(paymentSheetResult) { is PaymentSheetResult.Canceled -> { print("Canceled") } is PaymentSheetResult.Failed -> { print("Error: ${paymentSheetResult.error}") } is PaymentSheetResult.Completed -> { // Display for example, an order confirmation screen print("Completed") } } } } ``` Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento. ## Gestire gli eventi successivi al pagamento [Lato server] Stripe invia un evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) quando il pagamento viene completato. Utilizza lo [strumento webhook Dashboard](https://dashboard.stripe.com/webhooks) o segui la [guida ai webhook](https://docs.stripe.com/webhooks/quickstart.md) per ricevere questi eventi ed eseguire azioni come l’invio di una email per la conferma di un ordine al cliente, la registrazione della vendita in un database o l’avvio del flusso di lavoro per una spedizione. Ascolta questi eventi invece di attendere una chiamata di ritorno dal client. Sul client, il cliente potrebbe chiudere la finestra del browser o uscire dall’app prima dell’esecuzione della chiamata di ritorno e i client malintenzionati potrebbero manipolare la risposta. La configurazione dell’integrazione per l’ascolto di eventi asincroni ti consente di accettare [diversi tipi di modalità di pagamento](https://stripe.com/payments/payment-methods-guide) con una sola integrazione. Oltre alla gestione dell’evento `payment_intent.succeeded`, è consigliabile gestire altri eventi durante la riscossione di pagamenti tramite Payment Element: | Evento | Descrizione | Azione | | ------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded) | Inviato quando un cliente ha disposto un pagamento con esito positivo. | Invia al cliente la conferma di un ordine ed *evade* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) l’ordine. | | [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing) | Inviato quando un cliente ha correttamente disposto un pagamento che non è stato ancora completato. Questo evento viene di solito inviato quando il cliente dispone un addebito bancario. Sarà poi seguito da un evento `payment_intent.succeeded` o da un evento `payment_intent.payment_failed`. | Invia al cliente la conferma di un ordine che indica il pagamento in sospeso. Per i beni digitali, potresti voler evadere l’ordine senza attendere il completamento del pagamento. | | [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | Inviato quando il cliente ha tentato un pagamento che non è andato a buon fine. | Se un pagamento passa da `processing` a `payment_failed`, offri al cliente un altro tentativo di pagamento. | ## Addebitare in un secondo momento un importo sul PaymentMethod salvato [Lato server] > #### Conformità > > Quando salvi i dati di pagamento di un cliente, sei responsabile della conformità a tutte le leggi, le normative e le regole del circuito applicabili. Quando presenti al cliente finale i metodi di pagamento utilizzati in passato per acquisti futuri, accertati di elencare i metodi di pagamento per i quali hai raccolto il consenso a salvare i dati del metodo di pagamento per gli usi futuri specifici. Per differenziare i metodi di pagamento legati ai clienti che possono o non possono essere presentati al cliente finale come metodo di pagamento salvato per acquisti futuri, utilizza il parametro [allow_redisplay](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-allow_redisplay). Per individuare il metodo di pagamento da addebitare, elenca i metodi di pagamento associati al tuo cliente. In questo esempio vengono elencate le carte, ma puoi indicare qualsiasi [tipo](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-type) supportato. > #### Utilizza l'API Accounts v2 per rappresentare i clienti > > The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a [specify a preview version](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in your code. > > To request access to the Accounts v2 preview, > > Nella maggior parte dei casi d’uso, consigliamo di [rappresentare i clienti come oggetti Account configurati dall’utente,](https://docs.stripe.com/connect/use-accounts-as-customers.md) anziché utilizzare oggetti [Customer](https://docs.stripe.com/api/customers.md). #### Account v2 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d type=card ``` #### Clienti v1 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d type=card ``` Quando è tutto pronto per l’addebito al cliente *off-session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information), utilizza l’ID del cliente e l’ID del `PaymentMethod` per creare un `PaymentIntent` specificando l’importo e la valuta del pagamento. Imposta alcuni altri parametri per effettuare il pagamento off-session: - Impostare [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) a `true` per indicare che il cliente non è nel flusso di pagamento durante un tentativo di pagamento e non può soddisfare una richiesta di autenticazione effettuata da un partner, come una società emittente della carta, una banca o altro istituto di pagamento. Se, durante il flusso di pagamento, un partner richiede l’autenticazione, Stripe richiede le esenzioni utilizzando le informazioni sul cliente ricavate da una transazione precedente *all’interno della sessione* (A payment is described as on-session if it occurs while the customer is actively in your checkout flow and able to authenticate the payment method). Se le condizioni per l’esenzione non sono soddisfatte, il `PaymentIntent` potrebbe generare un errore. - Imposta il valore di [conferma](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) della proprietà `PaymentIntent` su true, per far sì che la conferma avvenga immediatamente quando crei il `PaymentIntent`. - Imposta [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) sull’ID del `PaymentMethod`. - SA seconda di come rappresenti i clienti nella tua integrazione, imposta [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) sull’ID dell’`Account` configurato dal cliente o [cliente](https://docs.stripe.com/api.md#create_payment_intent-customer) sull’ID del `Customer`. #### Account v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` #### Clienti v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer={{CUSTOMER_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` ## Testare l'integrazione #### Carte | Modalità di pagamento | Scenario | Come eseguire il test | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | | Carta di credito | La configurazione della carta ha esito positivo e non richiede l’*autenticazione* (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). | Compila il modulo per la carta di credito usando il numero di carta di credito `4242 4242 4242 4242` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta richiede l’autenticazione per la configurazione iniziale, poi ha esito positivo per i pagamenti successivi. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0025 0000 3155` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta richiede l’autenticazione per la configurazione iniziale e per i pagamenti successivi. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0027 6000 3184` con qualsiasi scadenza, CVC e codice postale. | | Carta di credito | La carta viene rifiutata durante la configurazione. | Compila il modulo per la carta di credito usando il numero di carta di credito `4000 0000 0000 9995` con qualsiasi scadenza, CVC e codice postale. | ## Optional: Abilitare Google Pay ### Configura la tua integrazione Per usare Google Pay, prima di tutto abilita l’API di Google Pay aggiungendo quanto segue al tag `` del tuo **AndroidManifest.xml**: ```xml ... ``` Per ulteriori informazioni, consulta la pagina [Set up Google Pay API](https://developers.google.com/pay/api/android/guides/setup) (Configurazione dell’API di Google Pay) di Google Pay per Android. ### Aggiungi Google Pay Per aggiungere Google Pay alla tua integrazione, specifica una [PaymentSheet.GooglePayConfiguration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-google-pay-configuration/index.html) con il tuo ambiente Google Pay (produzione o test) e il [codice paese della tua azienda](https://dashboard.stripe.com/settings/account) all’inizializzazione di [PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html). #### Kotlin ```kotlin val googlePayConfiguration = PaymentSheet.GooglePayConfiguration( environment = PaymentSheet.GooglePayConfiguration.Environment.Test, countryCode = "US", currencyCode = "USD" // Required for Setup Intents, optional for Payment Intents ) val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name") .googlePay(googlePayConfiguration) .build() ``` ### Testare Google Pay Google consente di effettuare pagamenti di test tramite la sua [suite di carte di test](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). La suite di test supporta l’utilizzo di [carte di test](https://docs.stripe.com/testing.md) Stripe. Devi testare Google Pay utilizzando un dispositivo Android fisico anziché un dispositivo simulato in un Paese in cui è supportato Google Pay. Accedi a un account Google sul tuo dispositivo di test con una carta reale salvata su Google Wallet. ## Optional: Personalizzare la scheda Tutte le personalizzazioni vengono configurate utilizzando l’oggetto [PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html). ### Aspetto Personalizza i colori, i caratteri e molto altro in base all’aspetto della tua app utilizzando l’[API Appearance](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=android). ### Layout del metodo di pagamento Configura il layout dei metodi di pagamento nel foglio utilizzando [paymentMethodLayout](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/-builder/index.html#2123253356%2FFunctions%2F2002900378). Puoi visualizzarli orizzontalmente, verticalmente o lasciare che Stripe ne ottimizzi il layout automaticamente. ![](https://b.stripecdn.com/docs-statics-srv/assets/android-mpe-payment-method-layouts.3bcfe828ceaad1a94e0572a22d91733f.png) #### Kotlin ```kotlin PaymentSheet.Configuration.Builder("Example, Inc.") .paymentMethodLayout(PaymentSheet.PaymentMethodLayout.Automatic) .build() ``` ### Acquisire gli indirizzi degli utenti Acquisisci gli indirizzi di spedizione o fatturazione locali e internazionali dai tuoi clienti utilizzando il componente [Address Element](https://docs.stripe.com/elements/address-element.md?platform=android). ### Nome attività da visualizzare Specifica un nome dell’attività per il cliente impostando [merchantDisplayName](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html#-191101533%2FProperties%2F2002900378). Per impostazione predefinita, viene utilizzato il nome della tua app. #### Kotlin ```kotlin PaymentSheet.Configuration.Builder( merchantDisplayName = "My app, Inc." ).build() ``` ### Modalità scura Per impostazione predefinita, il `PaymentSheet` si adatta automaticamente alle impostazioni di visualizzazione del sistema dell’utente (modalità chiara o scura). Puoi modificare questa impostazione configurando la modalità chiara o scura nella tua app: #### Kotlin ```kotlin // force dark AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES) // force light AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO) ``` ### Dettagli di addebito predefiniti Per impostare i valori predefiniti per i dettagli di addebito raccolti nella scheda di pagamento, configura la proprietà `defaultBillingDetails`. `PaymentSheet` precompila i campi della scheda con i valori che fornisci. #### Kotlin ```kotlin val address = PaymentSheet.Address(country = "US") val billingDetails = PaymentSheet.BillingDetails( address = address, email = "foo@bar.com" ) val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.") .defaultBillingDetails(billingDetails) .build() ``` ### Configura la raccolta dei dati di fatturazione Utilizza `BillingDetailsCollectionConfiguration` per specificare la modalità di raccolta dei dati di fatturazione nel PaymentSheet. Puoi acquisire il nome, l’indirizzo email, il numero di telefono e l’indirizzo del cliente. Se vuoi associare i dati di fatturazione predefiniti all’oggetto PaymentMethod anche quando tali campi non sono raccolti nell’interfaccia utente, imposta `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` su `true`. #### Kotlin ```kotlin val billingDetails = PaymentSheet.BillingDetails( email = "foo@bar.com" ) val billingDetailsCollectionConfiguration = BillingDetailsCollectionConfiguration( attachDefaultsToPaymentMethod = true, name = BillingDetailsCollectionConfiguration.CollectionMode.Always, email = BillingDetailsCollectionConfiguration.CollectionMode.Never, address = BillingDetailsCollectionConfiguration.AddressCollectionMode.Full, ) val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.") .defaultBillingDetails(billingDetails) .billingDetailsCollectionConfiguration(billingDetailsCollectionConfiguration) .build() ``` > Rivolgiti al tuo consulente legale per sapere quali sono le leggi applicabili alla raccolta di informazioni. Richiedi i numeri di telefono solo se necessari per la transazione. ## Optional: Completare il pagamento nell'interfaccia utente Puoi visualizzare il Payment Sheet solo per raccogliere i dati relativi alla modalità di pagamento e completare il pagamento nell’interfaccia utente dell’app. Questa opzione è utile se disponi di un pulsante personalizzato per l’acquisto o se occorrono passaggi aggiuntivi dopo la raccolta dei dati di pagamento. ![](https://b.stripecdn.com/docs-statics-srv/assets/android-multi-step.84d8a0a44b1baa596bda491322b6d9fd.png) > Un esempio di integrazione è [disponibile sul nostro GitHub](https://github.com/stripe/stripe-android/blob/master/paymentsheet-example/src/main/java/com/stripe/android/paymentsheet/example/samples/ui/paymentsheet/custom_flow/CustomFlowActivity.kt). 1. Innanzitutto, inizializza [PaymentSheet.FlowController](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html) invece di `PaymentSheet` usando uno dei metodi di [Builder](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/-builder/index.html). #### Android (Kotlin) ```kotlin class CheckoutActivity : AppCompatActivity() { private lateinit var flowController: PaymentSheet.FlowController override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val flowController = PaymentSheet.FlowController.Builder( resultCallback = ::onPaymentSheetResult, paymentOptionResultCallback = ::onPaymentOption, ).build(this) } } ``` 1. Poi chiama `configureWithPaymentIntent` con le chiavi degli oggetti Stripe recuperate dal tuo back-end e aggiorna la tua interfaccia utente nella callback con [getPaymentOption()](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-2091462043%2FFunctions%2F2002900378). Contiene un’immagine e un’etichetta che rappresentano il metodo di pagamento selezionato al momento dal cliente. #### Android (Kotlin) ```kotlin flowController.configureWithPaymentIntent( paymentIntentClientSecret = paymentIntentClientSecret, configuration = PaymentSheet.Configuration.Builder("Example, Inc.") .customer(PaymentSheet.CustomerConfiguration( id = customerId, ephemeralKeySecret = ephemeralKeySecret )) .build() ) { isReady, error -> if (isReady) { // Update your UI using `flowController.getPaymentOption()` } else { // handle FlowController configuration failure } } ``` 1. Poi chiama [presentPaymentOptions](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#449924733%2FFunctions%2F2002900378) per raccogliere i dati del pagamento. Quando il cliente termina l’operazione, la scheda si chiude e viene chiamata la [paymentOptionCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-option-callback/index.html) specificata in precedenza in `create`. Esegui questo metodo per aggiornare la tua interfaccia utente con la `paymentOption` restituita. #### Android (Kotlin) ```kotlin // ... flowController.presentPaymentOptions() // ... private fun onPaymentOption(paymentOptionResult: PaymentOptionResult) { val paymentOption = paymentOptionResult.paymentOption if (paymentOption != null) { paymentMethodButton.text = paymentOption.label paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds( paymentOption.drawableResourceId, 0, 0, 0 ) } else { paymentMethodButton.text = "Select" paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds( null, null, null, null ) } } ``` 1. Infine, chiama [confirm](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-479056656%2FFunctions%2F2002900378) per completare il pagamento. Quando il cliente termina l’operazione, la scheda si chiude e viene chiamata la [paymentResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html#237248767%2FFunctions%2F2002900378) specificata in precedenza in `create`. #### Android (Kotlin) ```kotlin // ... flowController.confirmPayment() // ... private fun onPaymentSheetResult( paymentSheetResult: PaymentSheetResult ) { when (paymentSheetResult) { is PaymentSheetResult.Canceled -> { // Payment canceled } is PaymentSheetResult.Failed -> { // Payment Failed. See logcat for details or inspect paymentSheetResult.error } is PaymentSheetResult.Completed -> { // Payment Complete } } } ``` Impostare `allowsDelayedPaymentMethods` su true consente di utilizzare i metodi di pagamento con [notifica differita](https://docs.stripe.com/payments/payment-methods.md#payment-notification) come i conti bancari degli Stati Uniti. Per questi metodi di pagamento, lo stato finale del pagamento non è noto al completamento di `PaymentSheet`, in quanto va a buon fine o meno in un secondo momento. Se supporti questi tipi di metodi di pagamento, informa il cliente che il suo ordine è confermato e procedi all’evasione (ad esempio alla spedizione del prodotto), spedisci il suo prodotto) solo quando avrai ricevuto il pagamento. # React Native > This is a React Native for when platform is react-native and mobile-ui is payment-element. View the full page at https://docs.stripe.com/payments/mobile/save-during-payment?platform=react-native&mobile-ui=payment-element. Usa l’[API Payment Intents](https://docs.stripe.com/api/payment_intents.md) per salvare i dati di pagamento da un acquisto. Esistono più casi d’uso: - Addebita un pagamento a un cliente per un ordine di e-commerce e memorizza i dati per gli acquisti futuri. - Avvia il primo di una serie di pagamenti ricorrenti. - Addebita un deposito e memorizza i dati per addebitare l’intero importo in seguito. > #### Transazioni con carta presente > > Le transazioni con carta presente, come i pagamenti tramite Stripe Terminal, utilizzano una procedura diversa per salvare il metodo di pagamento. Per i dettagli, consulta [la documentazione di Terminal](https://docs.stripe.com/terminal/features/saving-payment-details/save-after-payment.md). ## Conformità Sei responsabile del rispetto di tutte le leggi, i regolamenti e le norme di rete applicabili quando salvi i dettagli di pagamento di un cliente per un utilizzo futuro, ad esempio per mostrargli il metodo di pagamento nel flusso di checkout per un acquisto futuro o per addebitargli un importo quando non sta utilizzando attivamente il tuo sito web o la tua app. Prima di salvare o addebitare il metodo di pagamento di un cliente, assicurati di: - Aggiungere al tuo sito web o alla tua app delle clausole che specificano come intendi salvare i dettagli relativi ai metodi di pagamento, ad esempio: - L’accordo del cliente che ti consente di avviare un pagamento o una serie di pagamenti per suo conto per transazioni specifiche. - La tempistica e la frequenza dei pagamenti previste (ad esempio, se gli addebiti sono per rate programmate, pagamenti di abbonamenti o ricariche non programmate). - Il modo in cui determini l’importo del pagamento. - I tuoi termini di cancellazione, se la modalità di pagamento è per un servizio in abbonamento. - Utilizza un metodo di pagamento salvato solo per lo scopo indicato nei tuoi termini. - Ottieni il consenso esplicito del cliente per questo specifico utilizzo. Ad esempio, includi una casella di controllo “Salva il mio metodo di pagamento per il futuro”. - Conserva una copia dell’accordo scritto del cliente con i tuoi termini. ## Configurare Stripe [Lato server] [Lato client] Innanzitutto, hai bisogno di un Stripe account. [Registrati ora](https://dashboard.stripe.com/register). ### Lato server Per questa integrazione sono necessari endpoint sul server che comunicano con l’API Stripe. Utilizza le librerie ufficiali per accedere all’API Stripe dal tuo server: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Lato client L’[SDK React Native](https://github.com/stripe/stripe-react-native) è open source e completamente documentato. Internamente, utilizza SDK [iOS nativi](https://github.com/stripe/stripe-ios) e [Android](https://github.com/stripe/stripe-android). Per installare l’SDK React Native di Stripe, esegui uno dei seguenti comandi nella directory del progetto (a seconda del gestore di pacchetti utilizzato): #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Poi, installa alcune altre dipendenze necessarie: - Per iOS, vai alla directory **ios** ed esegui `pod install` per garantire di installare anche le dipendenze native richieste. - Per Android, non ci sono più dipendenze da installare. > Per aggiungere l’assistenza di TypeScript, ti consigliamo di consultare e seguire le indicazioni incluse nella [guida ufficiale di TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project). ### Inizializzazione di Stripe Per inizializzare Stripe nell’app React Native, esegui il wrapping della schermata di pagamento con il componente `StripeProvider` oppure utilizza il metodo di inizializzazione `initStripe`. È richiesta solo la [chiave pubblicabile](https://docs.stripe.com/keys.md#obtain-api-keys) dell’API in `publishableKey`. L’esempio seguente spiega come inizializzare Stripe utilizzando il componente `StripeProvider`. ```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 */} ); } ``` > Usa le [chiavi di test](https://docs.stripe.com/keys.md#obtain-api-keys) dell’API durante i test e le attività di sviluppo e le chiavi della [modalità live](https://docs.stripe.com/keys.md#test-live-modes) quando pubblichi l’app. ## Abilitare metodi di pagamento I pagamenti con carta sono abilitati per impostazione predefinita. Visualizza le [impostazioni dei metodi di pagamento](https://dashboard.stripe.com/settings/payment_methods) e abilita i metodi di pagamento che vuoi accettare. ## Aggiungi un endpoint [Lato server] > #### Nota > > Per visualizzare il PaymentSheet prima di creare un PaymentIntent, consulta [Raccogliere i dati di pagamento prima di creare un intento](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment). Questa integrazione utilizza tre oggetti dell’API Stripe: 1. [PaymentIntent](https://docs.stripe.com/api/payment_intents.md): Stripe lo utilizza per rappresentare la tua intenzione di riscuotere un pagamento da un cliente, monitorando i tentativi di addebito e le modifiche dello stato del pagamento durante la procedura. 1. Un [account configurato dal cliente](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) o un oggetto [Customer](https://docs.stripe.com/api/customers.md): per impostare un metodo di pagamento per pagamenti futuri, è necessario associarlo a un cliente. Crea un oggetto che rappresenti il tuo cliente quando crea un account presso la tua attività. Se il cliente effettua un pagamento come ospite, è possibile creare un oggetto `Account` o `Customer` prima del pagamento e associarlo in un secondo momento alla propria rappresentazione interna dell’account del cliente. 1. [CustomerSession](https://docs.stripe.com/api/customer_sessions.md): le informazioni relative all’oggetto che rappresenta il cliente sono sensibili e non possono essere recuperate direttamente da un’app. Una `CustomerSession` concede all’SDK un accesso temporaneo e limitato ad `Account` o `Cliente` e offre ulteriori opzioni di configurazione. Consulta l’elenco completo delle [opzioni di configurazione](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components). Per motivi di sicurezza, la tua app non può creare questi oggetti. Aggiungi invece un endpoint sul tuo server per: 1. Recupera `Account` o `Customer` o ne crea uno nuovo. 1. Crea una [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) per `Account` o `Customer`. 1. Crea un `PaymentIntent` con [importo](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount), [valuta](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency), [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage), e [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) o [cliente](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer). 1. Restituisce *chiave privata client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) del `PaymentIntent`,`client_secret` di `CustomerSession`, ID di `Account` o `Customer`, e [chiave pubblicabile](https://dashboard.stripe.com/apikeys) alla tua app. > Payment Element per dispositivi mobili supporta solo `setup_future_usage` con conti bancari degli Stati Uniti e carte di credito. I metodi di pagamento mostrati ai clienti durante il completamento della transazione sono inclusi anche nel PaymentIntent. Puoi consentire a Stripe di acquisire i metodi di pagamento dalle impostazioni della Dashboard oppure puoi elencarli manualmente. Indipendentemente dall’opzione che sceglierai, ricorda che la valuta specificata nel PaymentIntent filtra il metodo di pagamento mostrato al cliente. Ad esempio, se specifichi `eur` nel PaymentIntent e hai abilitato OXXO nella Dashboard, il cliente non vedrà OXXO perché questo metodo non supporta i pagamenti in `eur`. A meno che la tua integrazione non richieda un’opzione con codice per offrire i metodi di pagamento, Stripe consiglia l’opzione automatica. Ciò è dovuto al fatto che Stripe valuta le limitazioni dei metodi di pagamento, la valuta e altri parametri per determinare l’elenco dei metodi di pagamento accettati. I metodi di pagamento che migliorano la conversione e che sono più pertinenti alla valuta e alla posizione del cliente hanno la priorità. #### Gestire i metodi di pagamento dalla Dashboard Puoi gestire i metodi di pagamento dalla [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe determina la restituzione dei metodi di pagamento idonei in base a fattori quali l’importo della transazione, la valuta e il flusso di pagamento. Il PaymentIntent viene creato utilizzando i metodi di pagamento configurati nella Dashboard. Se non desideri utilizzare la Dashboard o se preferisci specificare manualmente i metodi di pagamento, puoi elencarli utilizzando l’attributo `payment_method_types`. #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "automatic_payment_methods[enabled]"=true \ ``` #### Elencare manualmente i metodi di pagamento #### Accounts v2 #### curl ```bash # Create an Account with the customer configuration (use an existing Account ID if this is a returning customer) curl https://api.stripe.com/v2/core/accounts \ -u <>: \ -X "POST" \ -d "configuration[customer]" # Create a CustomerSession for the Account curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer_account"="{{CUSTOMER_ACCOUNT_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` #### Customers v1 #### curl ```bash # Create a Customer (use an existing Customer ID if this is a returning customer) curl https://api.stripe.com/v1/customers \ -u <>: \ -X "POST" \ -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}" # Create an CustomerSession for the Customer curl https://api.stripe.com/v1/customer_sessions \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "components[mobile_payment_element][enabled]"=true \ -d "components[mobile_payment_element][features][payment_method_save]"=enabled \ -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \ -d "components[mobile_payment_element][features][payment_method_remove]"=enabled # Create a PaymentIntent curl https://api.stripe.com/v1/payment_intents \ -u <>: \ -X "POST" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "amount"=1099 \ -d "currency"="eur" \ -d "setup_future_usage"="off_session" \ -d "payment_method_types[]"="card" \ ``` > Ogni metodo di pagamento deve accettare la valuta specificata nel PaymentIntent e la tua attività deve avere la sede in uno dei Paesi accettati dal metodo di pagamento. Per ulteriori informazioni sulle funzionalità supportate, consulta la pagina dedicata alle [opzioni di integrazione dei metodi di pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md). ## Raccogliere i dati di pagamento [Lato client] Prima di visualizzare Payment Element per dispositivi mobili, la tua pagina di pagamento dovrebbe: - Mostrare i prodotti acquistati e l’importo totale - Acquisire le eventuali informazioni richieste per la spedizione - Includere un pulsante di pagamento per aprire l’interfaccia utente di Stripe Nella procedura di pagamento della tua app, invia una richiesta di rete all’endpoint di back-end che hai creato nella fase precedente e chiama `initPaymentSheet` dall’hook `useStripe`. #### Accounts v2 ```javascript export default function CheckoutScreen() { const { initPaymentSheet, presentPaymentSheet } = useStripe(); const [loading, setLoading] = useState(false); const fetchPaymentSheetParams = async () => { const response = await fetch(`${API_URL}/payment-sheet`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, }); const { paymentIntent, ephemeralKey, customer_account } = await response.json(); return { paymentIntent, ephemeralKey, customer_account, }; }; const initializePaymentSheet = async () => { const { paymentIntent, ephemeralKey, customer_account, } = await fetchPaymentSheetParams(); const { error } = await initPaymentSheet({ merchantDisplayName: "Example, Inc.", customerAccountId: customer_account, customerEphemeralKeySecret: ephemeralKey, paymentIntentClientSecret: paymentIntent, // Set `allowsDelayedPaymentMethods` to true if your business accepts payment // methods that complete payment after a delay, like SEPA Debit and Sofort. allowsDelayedPaymentMethods: true, defaultBillingDetails: { name: 'Jane Doe', } }); if (!error) { setLoading(true); } }; const openPaymentSheet = async () => { // see below }; useEffect(() => { initializePaymentSheet(); }, []); return (