# Configurer votre intégration Configurez un SDK Stripe Terminal ou une intégration pilotée par serveur pour accepter les paiements par TPE. # Intégration pilotée par serveur > This is a Intégration pilotée par serveur for when terminal-sdk-platform is server-driven. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=server-driven. Les intégrations pilotées par serveur utilisent l’API Stripe au lieu d’un SDK Terminal pour se connecter aux [lecteurs intelligents WisePOS E, Stripe S700/S710 et Verifone](https://docs.stripe.com/terminal/smart-readers.md) et encaisser les paiements par TPE. Cela vous permet de : - Utiliser Terminal, même si votre infrastructure n’est pas prise en charge par les SDK iOS, Android ou JavaScript - Développer une intégration Terminal propulsée par votre middleware personnalisé ou votre infrastructure basée sur le cloud - Intégrer n’importe quel appareil, y compris un point de vente basé sur .NET, à Terminal - Améliorer les connexions au réseau du lecteur en utilisant une connexion internet plutôt qu’une connexion à un réseau local - Utiliser des requêtes curl pour simuler une intégration L’intégration pilotée par le serveur ne prend pas en charge : - [Lecteurs mobiles Stripe Terminal](https://docs.stripe.com/terminal/mobile-readers.md) - [Encaissement des paiements par carte hors ligne](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md) ## Démarrer Vous pouvez démarrer votre intégration pilotée par serveur à l’aide du [guide de démarrage rapide Terminal](https://docs.stripe.com/terminal/quickstart.md) avec les composants suivants : - **Votre application de point de vente** : interface utilisateur que les employés voient lors de la création d’une transaction. - **Votre infrastructure de back-end** : traite les requêtes de votre application de point de vente et envoie des requêtes à l’API Stripe lors de la transaction. - **L’API Stripe** : reçoit les requêtes et les transmet à un lecteur intelligent, tel que le [lecteur BBPOS WisePOS E](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md), le [lecteur Stripe S700/S710](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md) ou le [lecteur Verifone](https://docs.stripe.com/terminal/payments/setup-reader/verifone.md). Stripe envoie également à votre infrastructure de back-end des *webhooks* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) indiquant l’état du paiement. - **Un lecteur BBPOS WisePOS E, lecteur Stripe S700/S710, lecteur Verifone ou lecteur de simulation** : invite le titulaire de la carte à régler son achat et communique avec Stripe et notre infrastructure financière pour traiter le paiement. Vous pouvez créer un lecteur de simulation si vous ne disposez pas encore d’un lecteur physique. ![Architecture d'intégration pilotée par serveur](https://b.stripecdn.com/docs-statics-srv/assets/server-driven-integration-architecture.a8499c1169a540cef98c9dd539f99a61.png) ## See also - [Guide de démarrage rapide de Terminal](https://docs.stripe.com/terminal/quickstart.md) - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=server-driven&reader-type=internet) # JavaScript > This is a JavaScript for when terminal-sdk-platform is js. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=js. > #### Recommandation pour les lecteurs intelligents > > Pour les lecteurs intelligents, tels que le [lecteur BBPOS WisePOS E](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md), le [lecteur Stripe S700/S710](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md) et [les lecteurs Verifone](https://docs.stripe.com/terminal/payments/setup-reader/verifone.md), nous recommandons d’utiliser l’[intégration pilotée par serveur](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=server-driven) au lieu du SDK JavaScript. > > Le SDK JavaScript requiert que votre POS et votre lecteur soient connectés au même réseau local avec un DNS local opérationnel. Cependant, l’intégration pilotée par le serveur s’appuie sur l’API Stripe, offrant une approche plus simple dans des environnements réseau complexes. Consultez notre [comparaison de plateformes](https://docs.stripe.com/terminal/payments/setup-reader.md#sdk) pour sélectionner la solution la plus adaptée à vos besoins. Si vous recherchez un document qui décrit plus en détail les méthodes, objets et erreurs disponibles, consultez notre [documentation complète sur les SDK](https://docs.stripe.com/terminal/references/api/js-sdk.md). ### Configuration requise pour le SDK Terminal JavaScript Lorsque vous intégrez des [lecteurs intelligents](https://docs.stripe.com/terminal/smart-readers.md) à l’aide du SDK JavaScript, assurez-vous que votre réseau répond à [nos exigences](https://docs.stripe.com/terminal/network-requirements.md). Pour démarrer avec le SDK JavaScript, suivez ces trois étapes : 1. [Installer le SDK et la bibliothèque client](https://docs.stripe.com/terminal/payments/setup-integration.md#install) sur votre page de paiement 1. [Configurer l’endpoint du token de connexion](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) sur votre application web et votre back-end. 1. [Initialiser le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#initialize) sur votre application web > Si vous intégrez votre application web à l’aide du SDK JavaScript, vous pouvez l’exécuter sur le navigateur d’un appareil mobile dès lors que cet appareil est connecté au même réseau local que le lecteur et que les appareils de ce réseau peuvent communiquer directement les uns avec les autres. ## Installer le SDK et la bibliothèque client [Côté client] [Côté serveur] #### Côté client Pour commencer, intégrez ce script à votre page de paiement. Ce script doit toujours être chargé directement à partir du site **https://js.stripe.com** pour des raisons de compatibilité avec les derniers logiciels du lecteur. Vous ne devez pas inclure le script dans un lot ni en héberger une copie ; si vous le faites, votre intégration pourrait être interrompue sans avertissement. ```html ``` #### Utiliser le SDK JS Terminal comme un module Nous proposons également un paquet npm pour charger et utiliser SDK JS Terminal en tant que module. Pour en savoir plus, consultez le [projet sur GitHub](https://github.com/stripe/terminal-js). > Pour en savoir plus sur la migration depuis une version bêta antérieure du SDK JavaScript, consultez le [Guide de migration vers Stripe Terminal Bêta](https://docs.stripe.com/terminal/references/sdk-migration-guide.md). #### Côté serveur Utilisez nos bibliothèques officielles pour accéder à l’API Stripe à partir de votre application : #### 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' ``` ## Configurer l'endpoint ConnectionToken [Côté serveur] [Côté client] #### Côté serveur Pour se connecter à un lecteur, votre back-end doit donner au SDK la permission d’utiliser le lecteur avec votre compte Stripe en lui fournissant la [clé secrète](https://docs.stripe.com/api/terminal/connection_tokens/object.md#terminal_connection_token_object-secret) d’un [ConnectionToken](https://docs.stripe.com/api/terminal/connection_tokens.md). Votre back-end doit créer des tokens de connexion uniquement pour les clients qu’il reconnaît comme fiables. #### curl ```bash curl https://api.stripe.com/v1/terminal/connection_tokens \ -u <>: \ -X "POST" ``` Obtenez la clé secrète à partir du `ConnectionToken` sur votre serveur et transmettez-la côté client. #### Ruby ```ruby post '/connection_token' do token = # ... Create or retrieve the ConnectionToken {secret: token.secret}.to_json end ``` > Le `secret` du `ConnectionToken` vous permet de vous connecter à n’importe quel lecteur Stripe Terminal et de traiter les paiements à l’aide de votre compte Stripe. Veillez à authentifier l’endpoint pour créer des tokens de connexion et à le protéger contre la falsification des requêtes intersites (CSRF). #### Côté client Pour permettre au SDK d’accéder à cet endpoint, créez une fonction dans votre application web qui demande un `ConnectionToken` à votre back-end et renvoie le `secret` de l’objet `ConnectionToken`. ```javascript async function fetchConnectionToken() { // Your backend should call /v1/terminal/connection_tokens and return the JSON response from Stripe const response = await fetch('https://{{YOUR_BACKEND_URL}}/connection_token', { method: "POST" }); const data = await response.json(); return data.secret; } ``` Cette fonction est appelée dès lors que le SDK doit s’authentifier auprès de Stripe ou du lecteur. Elle est également appelée lorsqu’un nouveau token est nécessaire pour se connecter à un lecteur (par exemple, lorsque votre application s’est déconnectée du lecteur). Si le SDK n’est pas en mesure de récupérer un nouveau jeton de connexion depuis votre backend, la connexion au lecteur échoue associée à une erreur de votre serveur. > Évitez de mettre en cache ou de coder en dur le token de connexion. Le SDK s’occupe de la gestion complète du cycle de vie du token de connexion. ## Initialiser le SDK [Côté client] > Chrome 142 (publié le 28 octobre 2025) et les versions ultérieures nécessitent une autorisation explicite avant que les sites Web puissent accéder aux appareils du réseau local (comme les lecteurs Terminal) lors de l’utilisation du SDK JavaScript Stripe Terminal. Pour les étapes de configuration et le dépannage, consultez les [instructions pour Chrome 142+](https://support.stripe.com/questions/ensuring-stripe-terminal-javascript-sdk-functionality-on-chrome-142). L’objet [StripeTerminal](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-create) fourni par le SDK présente une interface générique permettant de rechercher un lecteur, de se connecter à un lecteur et de créer des paiements. Afin de lancer une instance `StripeTerminal` sur votre application JavaScript, renseignez la fonction `ConnectionToken` mise en œuvre à [l’étape 2](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token). Vous devez également fournir une fonction pour traiter les déconnexions inattendues du lecteur, [onUnexpectedReaderDisconnect](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-create). Dans le cadre de cette fonction, votre application doit informer l’utilisateur de la déconnexion du lecteur. Vous pouvez également inclure un moyen de tenter une reconnexion à un lecteur. Pour en savoir plus, consultez la page [Traitement des déconnexions](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=js&reader-type=internet#handling-disconnects). ```javascript const terminal = StripeTerminal.create({ onFetchConnectionToken: fetchConnectionToken, onUnexpectedReaderDisconnect: unexpectedDisconnect, }); function unexpectedDisconnect() { // You might want to display UI to notify the user and start re-discovering readers } ``` ## Mises à jour du SDK Stripe publie régulièrement des mises à jour qui peuvent inclure de nouvelles fonctionnalités, des corrections de bugs et des mises à jour de sécurité. Mettez à jour votre SDK dès qu’une nouvelle version est disponible. Les SDK actuellement disponibles sont les suivants : - [SDK Stripe Terminal Android](https://github.com/stripe/stripe-terminal-android/releases) - [SDK Stripe Terminal iOS](https://github.com/stripe/stripe-terminal-ios/releases) - [SDK Stripe Terminal JavaScript](https://docs.stripe.com/terminal/references/api/js-sdk.md#changelog) - [SDK Stripe Terminal React Native](https://github.com/stripe/stripe-terminal-react-native) ## Navigateurs pris en charge Nous mettons tout en œuvre pour que le SDK JavaScript Stripe Terminal prenne en charge toutes les versions récentes des principaux navigateurs. Nous prenons en charge les fonctionnalités suivantes : - Edge sur Windows. - Firefox pour ordinateur de bureau. - Chrome et Safari, toutes plateformes. - Le navigateur natif Android sur Android 4.4 et versions ultérieures. Si vous rencontrez des problèmes avec le SDK JavaScript Stripe Terminal sur un navigateur donné, envoyez un e-mail à [support-terminal@stripe.com](mailto:support-terminal@stripe.com). > Remarque : L’utilisation du SDK JavaScript de Stripe Terminal avec React Native n’est pas prise en charge. Pour intégrer Stripe Terminal à votre application mobile avec React Native, utilisez le [SDK Stripe Terminal React Native](https://github.com/stripe/stripe-terminal-react-native). ## Prochaines étapes - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=js&reader-type=internet) # iOS > This is a iOS for when terminal-sdk-platform is ios. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=ios. Si vous recherchez un document qui décrit plus en détail les méthodes, objets et erreurs disponibles, consultez notre [documentation complète sur les SDK](https://stripe.dev/stripe-terminal-ios). Pour démarrer avec le SDK iOS, suivez ces quatre étapes : 1. [Installer le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#install) dans votre application. 1. [Configurer](https://docs.stripe.com/terminal/payments/setup-integration.md#configure) votre application. 1. [Configurer l’endpoint du token de connexion](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) dans votre application et votre back-end. 1. [Initialiser le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#initialize) dans votre application. ## Installer le SDK [Côté client] Le SDK Stripe Terminal iOS est compatible avec les applications qui : - Prennent en charge iOS 13 et les versions ultérieures - Sont installés avec CocoaPods, Swift Package Manager, ou en intégrant manuellement le framework #### Cocoapods 1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un : ```bash pod init ``` 1. Ajoutez cette ligne à votre Podfile : ```podfile pod 'StripeTerminal', '~> 5.0' ``` 1. Exécutez la commande suivante : ```bash pod install ``` 1. À partir de maintenant, utilisez le fichier `.xcworkspace` au lieu de `.xcodeproj` pour ouvrir votre projet dans Xcode. #### Swift Package Manager 1. Dans Xcode, sélectionnez **Fichier** > **Ajouter des packages…** dans la barre de menus. 1. Saisissez l’URL Github du SDK iOS Terminal Stripe : `https://github.com/stripe/stripe-terminal-ios` 1. Saisissez la version SDK que vous souhaitez installer dans votre projet. La valeur par défaut « Up to Next Major » vous aidera à installer les mises à jour de sécurité et de fonctionnalité sans entraîner de changements brutaux et imprévus. #### Manuel 1. Visitez le référentiel de Stripe Terminal iOS sur GitHub et accédez à la [dernière version en date](https://github.com/stripe/stripe-terminal-ios/releases). 1. Téléchargez le fichier `StripeTerminal.xcframework.zip` joint à la version GitHub. 1. Décompressez le fichier, plus glissez-déposez le XCFramework dans votre projet Xcode. 1. S’il n’est pas possible de charger les symboles de l’infrastructure logicielle, rendez-vous dans le volet « General » (Général) de votre cible et trouvez la liste déroulante « Frameworks, Libraries, and Embedded Content » (Infrastructures logicielles, bibliothèques et contenus intégrés). Dans `StripeTerminal.xcframework`, remplacez « Do Not Embed » (Ne pas intégrer) par « Embed and Sign » (Intégrer et signer). > Pour plus de détails sur la dernière version du SDK et les versions précédentes, consultez la page [Releases](https://github.com/stripe/stripe-terminal-ios/releases) sur GitHub. Pour recevoir des notifications lorsqu’une nouvelle version est publiée, [surveillez les versions du dépôt](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository) ou [abonnez-vous au flux RSS GitHub Releases](https://github.com/stripe/stripe-terminal-ios/releases.atom). > > Pour en savoir plus sur la migration depuis des versions antérieures du SDK iOS, consultez [le guide de migration du SDK Stripe Terminal](https://docs.stripe.com/terminal/references/sdk-migration-guide.md). ## Configurer votre application [Côté client] Pour que votre application puisse fonctionner avec le SDK Stripe Terminal, apportez quelques modifications à votre fichier **Info.plist** dans Xcode. 1. Activez les services de localisation avec la paire clé-valeur suivante. | Confidentialité – Description de l’utilisation de l’emplacement, le cas échéant | | ------------------------------------------------------------------------------- | | **Clé** | [NSLocationWhenInUseUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nslocationwheninuseusagedescription) | | **Valeur** | **L’accès à l’emplacement est indispensable pour accepter des paiements.** | Afin de réduire les risques de fraude associés aux paiements et de limiter le nombre de litiges, Stripe a besoin de connaître le lieu où se déroulent les paiements. Si le SDK ne peut déterminer l’emplacement de l’appareil iOS, les paiements sont désactivés jusqu’à ce que l’accès à l’emplacement soit rétabli. 1. Assurez-vous que votre application fonctionne en arrière-plan et reste connectée aux lecteurs Bluetooth. | Modes d’arrière-plan requis pour les lecteurs Bluetooth | | ------------------------------------------------------- | | **Clé** | [UIBackgroundModes](https://developer.apple.com/documentation/bundleresources/information_property_list/uibackgroundmodes) | | **Valeur** | **bluetooth-central** (Utilise les accessoires Bluetooth LE) | La configuration du mode d’arrière-plan [bluetooth-central](https://developer.apple.com/library/archive/documentation/NetworkingInternetWeb/Conceptual/CoreBluetooth_concepts/CoreBluetoothBackgroundProcessingForIOSApps/PerformingTasksWhileYourAppIsInTheBackground.html#//apple_ref/doc/uid/TP40013257-CH7-SW6) permet au lecteur de rester en mode veille lorsque votre application est exécutée en arrière-plan, ou lorsque l’appareil iOS est verrouillé. Sans cette valeur, la mise en veille échoue. Lorsque votre application est exécutée en arrière-plan, le lecteur est susceptible de s’éteindre automatiquement afin d’économiser de l’énergie. 1. Autorisez votre application à afficher une boîte de dialogue d’autorisation Bluetooth. L’App Store exige l’intégration de cette option, même si votre application ne prend pas en charge la connexion aux lecteurs Bluetooth. | Confidentialité – Description de l’utilisation systématique du Bluetooth | | ------------------------------------------------------------------------ | | **Clé** | [NSBluetoothAlwaysUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/NSBluetoothAlwaysUsageDescription) | | **Valeur** | **Cette application utilise le Bluetooth pour se connecter aux lecteurs de cartes bancaires pris en charge.** | iOS 13 propose désormais des autorisations plus spécifiques concernant l’utilisation de périphériques Bluetooth par une application. Les applications associées à Core Bluetooth doivent inclure cette clé dans leur fichier Info.plist afin d’éviter que l’application ne plante lors de son premier lancement. 1. Passer les contrôles de validation de l’application lorsque vous la soumettez à l’App Store. À partir de la version 3.4.0 du SDK, cette exigence d’autorisation est supprimée. | Confidentialité – Description de l’utilisation du périphérique Bluetooth | | ------------------------------------------------------------------------ | | **Clé** | [NSBluetoothPeripheralUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nsbluetoothperipheralusagedescription) | | **Valeur** | **La connexion aux lecteurs de cartes pris en charge nécessite un accès au Bluetooth.** | Ceci est un exemple ; vous pouvez reformuler la demande d’autorisation de l’utilisateur dans votre application. 1. Sauvegardez le fichier **Info.plist** de votre application. Il est désormais correctement configuré et peut être utilisé avec le SDK Stripe Terminal. > Si vous utilisez Tap to Pay sur iPhone, vous devez [demander et configurer](https://developer.apple.com/documentation/proximityreader/setting-up-the-entitlement-for-tap-to-pay-on-iphone) le droit de développement Tap to Pay sur iPhone à partir de votre compte Apple Developer. ## Configurer l'endpoint ConnectionToken [Côté serveur] [Côté client] ### Côté serveur Pour se connecter à un lecteur, votre back-end doit donner au SDK la permission d’utiliser le lecteur avec votre compte Stripe en lui fournissant la [clé secrète](https://docs.stripe.com/api/terminal/connection_tokens/object.md#terminal_connection_token_object-secret) d’un [ConnectionToken](https://docs.stripe.com/api/terminal/connection_tokens.md). Votre back-end doit créer des tokens de connexion uniquement pour les clients qu’il reconnaît comme fiables. #### curl ```bash curl https://api.stripe.com/v1/terminal/connection_tokens \ -u <>: \ -X "POST" ``` Obtenez la clé secrète à partir du `ConnectionToken` sur votre serveur et transmettez-la côté client. #### Ruby ```ruby post '/connection_token' do token = # ... Create or retrieve the ConnectionToken {secret: token.secret}.to_json end ``` > Le `secret` du `ConnectionToken` vous permet de vous connecter à n’importe quel lecteur Stripe Terminal et de traiter les paiements à l’aide de votre compte Stripe. Veillez à authentifier l’endpoint pour créer des tokens de connexion et à le protéger contre la falsification des requêtes intersites (CSRF). ### Côté client Afin de permettre au SDK d’accéder à cet endpoint, déployez le protocole [ConnectionTokenProvider](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPConnectionTokenProvider.html) dans votre application. Celui-ci définit une fonction unique qui demande un `ConnectionToken` à votre back-end. ```swift import StripeTerminal // Example API client class for communicating with your backend class APIClient: ConnectionTokenProvider { // For simplicity, this example class is a singleton static let shared = APIClient() // Fetches a ConnectionToken from your backend func fetchConnectionToken(_ completion: @escaping ConnectionTokenCompletionBlock) { let config = URLSessionConfiguration.default let session = URLSession(configuration: config) guard let url = URL(string: "https://{{YOUR_BACKEND_URL}}/connection_token") else { fatalError("Invalid backend URL") } var request = URLRequest(url: url) request.httpMethod = "POST" let task = session.dataTask(with: request) { (data, response, error) in if let data = data { do { // Warning: casting using `as? [String: String]` looks simpler, but isn't safe: let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] if let secret = json?["secret"] as? String { completion(secret, nil) } else { let error = NSError(domain: "com.stripe-terminal-ios.example", code: 2000, userInfo: [NSLocalizedDescriptionKey: "Missing `secret` in ConnectionToken JSON response"]) completion(nil, error) } } catch { completion(nil, error) } } else { let error = NSError(domain: "com.stripe-terminal-ios.example", code: 1000, userInfo: [NSLocalizedDescriptionKey: "No data in response from ConnectionToken endpoint"]) completion(nil, error) } } task.resume() } } ``` Cette fonction est appelée dès lors que le SDK doit s’authentifier auprès de Stripe ou du lecteur. Elle est également appelée lorsqu’un nouveau token est nécessaire pour se connecter à un lecteur (par exemple, lorsque votre application s’est déconnectée du lecteur). Si le SDK n’est pas en mesure de récupérer un nouveau jeton de connexion depuis votre backend, la connexion au lecteur échoue associée à une erreur de votre serveur. > Évitez de mettre en cache ou de coder en dur le token de connexion. Le SDK s’occupe de la gestion complète du cycle de vie du token de connexion. > #### Épinglage des certificats > > Dans la plupart des cas, vous ne devez pas configurer votre application avec l’épinglage de certificats. Si votre application l’exige, consultez la documentation sur l’[épinglage des certificats](https://docs.stripe.com/tls-certificates.md#certificate-pinning). ## Initialiser le SDK [Côté client] La classe [Terminal](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html) mise à disposition par le SDK Stripe Terminal dispose d’une interface générique permettant de détecter les lecteurs, de se connecter à un lecteur et d’effectuer des opérations sur le lecteur, telles que l’affichage des informations du panier, l’encaissement de paiements et l’enregistrement de cartes bancaires pour une utilisation ultérieure. Fournissez le `ConnectionTokenProvider` que vous avez implémenté lors de la [configuration du token de connexion](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token). Appelez `initWithTokenProvider` une seule fois dans votre application avant d’accéder à `Terminal.shared`, généralement dans le `application:didFinishLaunchingWithOptions` de la méthode `AppDelegate` ou dans l’`init()` de votre type d’`App` SwiftUI. Vous pouvez également utiliser `dispatch_once` dans Objective-C ou un initialiseur `static` dans Swift. ```swift import UIKit import StripeTerminal @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { Terminal.initWithTokenProvider(APIClient.shared) // ... return true } // ... } ``` ## Mises à jour du SDK Stripe publie régulièrement des mises à jour qui peuvent inclure de nouvelles fonctionnalités, des corrections de bugs et des mises à jour de sécurité. Mettez à jour votre SDK dès qu’une nouvelle version est disponible. Les SDK actuellement disponibles sont les suivants : - [SDK Stripe Terminal Android](https://github.com/stripe/stripe-terminal-android/releases) - [SDK Stripe Terminal iOS](https://github.com/stripe/stripe-terminal-ios/releases) - [SDK Stripe Terminal JavaScript](https://docs.stripe.com/terminal/references/api/js-sdk.md#changelog) - [SDK Stripe Terminal React Native](https://github.com/stripe/stripe-terminal-react-native) ## Prochaines étapes - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=ios&reader-type=internet) # Android > This is a Android for when terminal-sdk-platform is android. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=android. Pour obtenir plus informations sur l’ensemble des méthodes, des objets et des erreurs disponibles, consultez notre [documentation complète sur les SDK](https://stripe.dev/stripe-terminal-android/). Pour démarrer avec le SDK Android, suivez ces quatre étapes : 1. [Installer le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#install) dans votre application. 1. [Configurer](https://docs.stripe.com/terminal/payments/setup-integration.md#configure) votre application. 1. [Configurer l’endpoint du token de connexion](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) dans votre application et votre back-end. 1. [Initialiser le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#initialize) dans votre application. ## Installer le SDK [Côté client] > Le SDK n’est plus compatible avec les bibliothèques d’assistance, car nous utilisons Room pour enregistrer et gérer l’état de l’application tout au long de son cycle de vie. Assurez-vous que votre application a migré vers AndroidX. Pour installer le SDK, ajoutez `stripeterminal` au bloc `dependencies` du [fichier build de votre application](https://developer.android.com/studio/build/dependencies) : #### Kotlin ```kotlin plugins { id("com.android.application") } android { ... } dependencies { implementation("com.stripe:stripeterminal:5.3.0") // ... } ``` ### (Facultatif) Prise en charge des coroutines Kotlin SDK version 5.0.0 includes an optional module, `stripeterminal-ktx`. This module provides `suspend` function wrappers for asynchronous Terminal APIs, allowing you to write simple, sequential code instead of nesting callbacks. Pour l’utiliser, ajoutez sa dépendance : #### Kotlin ```kotlin dependencies { implementation("com.stripe:stripeterminal:5.3.0") // Add the coroutines module implementation("com.stripe:stripeterminal-ktx:5.3.0") // ... } ``` Voir un exemple de ce modèle d’intégration dans notre [application Kotlin exemple](https://github.com/stripe/stripe-terminal-android/tree/master/Example/kotlinapp) sur GitHub. ### Définir la version Java cible Ensuite, étant donné que le SDK repose sur Java 8, le fichier de build de votre application doit l’indiquer en précisant la version Java cible : #### Kotlin ```kotlin android { // ... compileOptions { sourceCompatibility = JavaVersion.VERSION_1_8 targetCompatibility = JavaVersion.VERSION_1_8 } kotlinOptions { jvmTarget = "1.8" } } ``` > Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-terminal-android/releases) sur GitHub. Pour savoir quand une nouvelle version est disponible, [surveillez les versions du référentiel](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). > > Pour en savoir plus sur la migration à partir de versions antérieures ou bêta du SDK Android, consultez le [guide de migration Stripe Terminal](https://docs.stripe.com/terminal/references/sdk-migration-guide.md). ## Configurer votre application [Côté client] Vous devez activer l’autorisation `ACCESS_FINE_LOCATION`. Pour connecter un lecteur Bluetooth, vous devez également activer les autorisations Bluetooth. Ajoutez les autorisations appropriées à votre manifeste, comme indiqué ici : ```xml ``` Avant d’initialiser l’objet [Terminal](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/index.html), ajoutez la vérification suivante afin de vérifier que l’autorisation `ACCESS_FINE_LOCATION` est activée dans votre application : ```kotlin if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) { val permissions = arrayOf(android.Manifest.permission.ACCESS_FINE_LOCATION) ActivityCompat.requestPermissions(this, permissions, REQUEST_CODE_LOCATION) } ``` Vérifiez également que l’utilisateur de l’application accorde l’autorisation d’accéder aux emplacements ; le SDK ne peut fonctionner sans elle. À cet effet, remplacez la méthode `onRequestPermissionsResult` dans votre application et vérifiez le résultat de l’autorisation. ```kotlin override fun onRequestPermissionsResult( requestCode: Int, permissions: Array, grantResults: IntArray ) { super.onRequestPermissionsResult(requestCode, permissions, grantResults) if (requestCode == REQUEST_CODE_LOCATION && grantResults.isNotEmpty() && grantResults[0] != PackageManager.PERMISSION_GRANTED ) { throw RuntimeException("Location services are required to connect to a reader.") } } ``` Vous devez également vous assurer que les services de localisation et Bluetooth sont activés sur l’appareil, et pas seulement pour l’application. Voici un exemple de ce à quoi cela peut ressembler dans les paramètres de l’appareil : ![Capture d’écran de la page des paramètres de localisation sur un appareil Android.](https://b.stripecdn.com/docs-statics-srv/assets/android-example-location-settings.af2781f0325786bd2ecb26b19e3b3a2f.png) Paramètres d’emplacement ![Capture d’écran de la page des paramètres Bluetooth sur un appareil Android.](https://b.stripecdn.com/docs-statics-srv/assets/android-example-bluetooth-settings.f5878ba77b1375006165dff2719725f3.png) Paramètres Bluetooth > Afin de réduire les risques de fraude associés aux paiements, et de limiter le nombre de litiges, Stripe a besoin de connaître le lieu où se déroulent les paiements. Si le SDK ne peut déterminer l’emplacement de l’appareil Android, les paiements sont désactivés jusqu’à ce que l’accès à l’emplacement soit rétabli. ## Configurer l'endpoint ConnectionToken [Côté serveur] [Côté client] ### Côté serveur Pour se connecter à un lecteur, votre back-end doit donner au SDK la permission d’utiliser le lecteur avec votre compte Stripe en lui fournissant la [clé secrète](https://docs.stripe.com/api/terminal/connection_tokens/object.md#terminal_connection_token_object-secret) d’un [ConnectionToken](https://docs.stripe.com/api/terminal/connection_tokens.md). Votre back-end doit créer des tokens de connexion uniquement pour les clients qu’il reconnaît comme fiables. #### curl ```bash curl https://api.stripe.com/v1/terminal/connection_tokens \ -u <>: \ -X "POST" ``` Obtenez la clé secrète à partir du `ConnectionToken` sur votre serveur et transmettez-la côté client. #### Ruby ```ruby post '/connection_token' do token = # ... Create or retrieve the ConnectionToken {secret: token.secret}.to_json end ``` > Le `secret` du `ConnectionToken` vous permet de vous connecter à n’importe quel lecteur Stripe Terminal et de traiter les paiements à l’aide de votre compte Stripe. Veillez à authentifier l’endpoint pour créer des tokens de connexion et à le protéger contre la falsification des requêtes intersites (CSRF). ### Côté client Afin de permettre au SDK d’accéder à cet endpoint, déployez l’interface [ConnectionTokenProvider](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-connection-token-provider/index.html) dans votre application. Celle-ci définit une fonction unique qui demande un `ConnectionToken` à votre back-end. ```kotlin class CustomConnectionTokenProvider : ConnectionTokenProvider { override fun fetchConnectionToken(callback: ConnectionTokenCallback) { try { // Your backend should call /v1/terminal/connection_tokens and return the // JSON response from Stripe. When the request to your backend succeeds, // return the `secret` from the response to the SDK. callback.onSuccess(secret) } catch (e: Exception) { callback.onFailure( ConnectionTokenException("Failed to fetch connection token", e) ) } } } ``` Cette fonction est appelée dès lors que le SDK doit s’authentifier auprès de Stripe ou du lecteur. Elle est également appelée lorsqu’un nouveau token est nécessaire pour se connecter à un lecteur (par exemple, lorsque votre application s’est déconnectée du lecteur). Si le SDK n’est pas en mesure de récupérer un nouveau jeton de connexion depuis votre backend, la connexion au lecteur échoue associée à une erreur de votre serveur. > Évitez de mettre en cache ou de coder en dur le token de connexion. Le SDK s’occupe de la gestion complète du cycle de vie du token de connexion. > #### Épinglage des certificats > > Dans la plupart des cas, vous ne devez pas configurer votre application avec l’épinglage de certificats. Si votre application l’exige, consultez la documentation sur l’[épinglage des certificats](https://docs.stripe.com/tls-certificates.md#certificate-pinning). ## Initialiser le SDK [Côté client] Le SDK Android est sensible au cycle de vie. Pour éviter les fuites de mémoire et garantir un nettoyage approprié des processus de longue durée du SDK Terminal, votre application doit implémenter une sous-classe `Application` qui utilise `TerminalApplicationDelegate.onCreate()` pour informer le SDK des événements de cycle de vie. ```kotlin // Substitute with your application name, and remember to keep it the same as your AndroidManifest.xml class StripeTerminalApplication : Application() { override fun onCreate() { super.onCreate() TerminalApplicationDelegate.onCreate(this) } } ``` > Si vous souhaitez utiliser Tap to Pay sur Android (TTPA), l’initialisation dans `Application` est légèrement différente de cet exemple. Consultez [Se connecter à un lecteur avec TTPA](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=tap-to-pay#initialize). La classe [Terminal](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/index.html) mise à disposition par le SDK Stripe Terminal dispose d’une interface générique permettant de détecter les lecteurs, de se connecter à un lecteur et d’effectuer des opérations sur le lecteur, telles que l’affichage des informations du panier, l’encaissement de paiements et l’enregistrement de cartes bancaires pour une utilisation ultérieure. Pour commencer, fournissez le contexte actuel de l’application, le [ConnectionTokenProvider](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-connection-token-provider/index.html) implémenté à l’[Étape 3](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) et un objet [TerminalListener](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-terminal-listener/index.html). Vous pouvez utiliser cet écouteur pour gérer des événements tels que des paiements et des mises à jour de l’état de la connexion à partir du SDK. ```kotlin // Create your listener object. Override any methods that you want to be notified about val listener = object : TerminalListener { override fun onConnectionStatusChange(status: ConnectionStatus) { println("onConnectionStatusChange: $status"); } override fun onPaymentStatusChange(status: PaymentStatus) { println("onPaymentStatusChange: $status"); } } // Choose the level of messages that should be logged to your console val logLevel = LogLevel.VERBOSE // Create your token provider. val tokenProvider = CustomConnectionTokenProvider() // Offline listener is optional and only needed if processing offline transactions. // See https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments val offlineListener: OfflineListener? = null // Pass in the current application context, your desired logging level, your token provider, and the listener you created if (!Terminal.isInitialized()) { Terminal.init(applicationContext, logLevel, tokenProvider, listener, offlineListener) } // Since the Terminal is a singleton, you can call getInstance whenever you need it Terminal.getInstance() ``` ## Mises à jour du SDK Stripe publie régulièrement des mises à jour qui peuvent inclure de nouvelles fonctionnalités, des corrections de bugs et des mises à jour de sécurité. Mettez à jour votre SDK dès qu’une nouvelle version est disponible. Les SDK actuellement disponibles sont les suivants : - [SDK Stripe Terminal Android](https://github.com/stripe/stripe-terminal-android/releases) - [SDK Stripe Terminal iOS](https://github.com/stripe/stripe-terminal-ios/releases) - [SDK Stripe Terminal JavaScript](https://docs.stripe.com/terminal/references/api/js-sdk.md#changelog) - [SDK Stripe Terminal React Native](https://github.com/stripe/stripe-terminal-react-native) ## Prochaines étapes - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=internet) # React Native > This is a React Native for when terminal-sdk-platform is react-native. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=react-native. > La bibliothèque React Native de Terminal est disponible en [version bêta publique](https://docs.stripe.com/release-phases.md) et en développement actif. Veuillez signaler tout problème rencontré sur notre [projet GitHub](https://github.com/stripe/stripe-terminal-react-native/issues/new/choose). Pour démarrer avec le SDK React Native, suivez ces quatre étapes : 1. [Installer le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#install) dans votre application. 1. [Configurer](https://docs.stripe.com/terminal/payments/setup-integration.md#configure) votre application. 1. [Configurer l’endpoint du token de connexion](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) dans votre application et votre back-end. 1. [Initialiser le SDK](https://docs.stripe.com/terminal/payments/setup-integration.md#initialize) dans votre application. > Si vous créez une intégration **Applications sur des appareils** (exécutant votre application sur des lecteurs intelligents Stripe tels que le S700/S710), vous devrez effectuer des étapes supplémentaires de [configuration Android native](https://docs.stripe.com/terminal/features/apps-on-devices/build.md?terminal-sdk-platform=react-native#setup-app) après avoir suivi ce guide. ## Installer le SDK [Côté client] Le [SDK React Native](https://github.com/stripe/stripe-terminal-react-native) est disponible en open source et fait l’objet d’une documentation complète. En interne, il utilise les SDK iOS et Android natifs. Pour installer le SDK, veuillez exécuter : #### NPM ```bash npm install @stripe/stripe-terminal-react-native ``` #### Yarn ```bash yarn add @stripe/stripe-terminal-react-native ``` #### Expo ```bash npx expo install @stripe/stripe-terminal-react-native ``` ## Configurer votre application [Côté client] #### Interface de ligne de commande React Native #### iOS ### Pods Vous devez exécuter `pod install` dans votre répertoire `ios` pour installer les dépendances natives. ### Autorisations Pour que votre application puisse fonctionner avec le SDK Stripe Terminal, apportez quelques modifications à votre fichier **Info.plist** dans Xcode. 1. Activez les services de localisation avec la paire clé-valeur suivante. | Confidentialité – Description de l’utilisation de l’emplacement, le cas échéant | | ------------------------------------------------------------------------------- | | **Clé** | [NSLocationWhenInUseUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nslocationwheninuseusagedescription) | | **Valeur** | **L’accès à l’emplacement est indispensable pour accepter des paiements.** | Afin de réduire les risques de fraude associés aux paiements et de limiter le nombre de litiges, Stripe a besoin de connaître le lieu où se déroulent les paiements. Si le SDK ne peut déterminer l’emplacement de l’appareil iOS, les paiements sont désactivés jusqu’à ce que l’accès à l’emplacement soit rétabli. 1. Assurez-vous que votre application fonctionne en arrière-plan et reste connectée aux lecteurs Bluetooth. | Modes d’arrière-plan requis pour les lecteurs Bluetooth | | ------------------------------------------------------- | | **Clé** | [UIBackgroundModes](https://developer.apple.com/documentation/bundleresources/information_property_list/uibackgroundmodes) | | **Valeur** | **bluetooth-central** (Utilise les accessoires Bluetooth LE) | La configuration du mode d’arrière-plan [bluetooth-central](https://developer.apple.com/library/archive/documentation/NetworkingInternetWeb/Conceptual/CoreBluetooth_concepts/CoreBluetoothBackgroundProcessingForIOSApps/PerformingTasksWhileYourAppIsInTheBackground.html#//apple_ref/doc/uid/TP40013257-CH7-SW6) permet au lecteur de rester en mode veille lorsque votre application est exécutée en arrière-plan, ou lorsque l’appareil iOS est verrouillé. Sans cette valeur, la mise en veille échoue. Lorsque votre application est exécutée en arrière-plan, le lecteur est susceptible de s’éteindre automatiquement afin d’économiser de l’énergie. 1. Autorisez votre application à afficher une boîte de dialogue d’autorisation Bluetooth. L’App Store exige l’intégration de cette option, même si votre application ne prend pas en charge la connexion aux lecteurs Bluetooth. | Confidentialité – Description de l’utilisation systématique du Bluetooth | | ------------------------------------------------------------------------ | | **Clé** | [NSBluetoothAlwaysUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/NSBluetoothAlwaysUsageDescription) | | **Valeur** | **Cette application utilise le Bluetooth pour se connecter aux lecteurs de cartes bancaires pris en charge.** | iOS 13 propose désormais des autorisations plus spécifiques concernant l’utilisation de périphériques Bluetooth par une application. Les applications associées à Core Bluetooth doivent inclure cette clé dans leur fichier Info.plist afin d’éviter que l’application ne plante lors de son premier lancement. 1. Passer les contrôles de validation de l’application lorsque vous la soumettez à l’App Store. À partir de la version 3.4.0 du SDK, cette exigence d’autorisation est supprimée. | Confidentialité – Description de l’utilisation du périphérique Bluetooth | | ------------------------------------------------------------------------ | | **Clé** | [NSBluetoothPeripheralUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nsbluetoothperipheralusagedescription) | | **Valeur** | **La connexion aux lecteurs de cartes pris en charge nécessite un accès au Bluetooth.** | Ceci est un exemple ; vous pouvez reformuler la demande d’autorisation de l’utilisateur dans votre application. 1. Sauvegardez le fichier **Info.plist** de votre application. Il est désormais correctement configuré et peut être utilisé avec le SDK Stripe Terminal. > Si vous utilisez Tap to Pay sur iPhone, vous devez [demander et configurer](https://developer.apple.com/documentation/proximityreader/setting-up-the-entitlement-for-tap-to-pay-on-iphone) le droit de développement Tap to Pay sur iPhone à partir de votre compte Apple Developer. #### Android ### Autorisations Le SDK Stripe Terminal nécessite les autorisations Android suivantes pour fonctionner correctement : - `PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT` - `PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN` - `PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION` Utilisez la fonction utilitaire `requestNeededAndroidPermissions` pour demander automatiquement toutes les autorisations requises avant d’initialiser le SDK Terminal : ```js import { requestNeededAndroidPermissions } from '@stripe/stripe-terminal-react-native'; try { const granted = await requestNeededAndroidPermissions({ accessFineLocation: { title: 'Location Permission', message: 'Stripe Terminal needs access to your location', buttonPositive: 'Accept', }, }); if (granted) { // Initialize the SDK } else { console.error( 'Location and BT services are required to connect to a reader.' ); } } catch (e) { console.error(e); } ``` Sinon, si vous avez besoin d’un contrôle précis sur les demandes d’autorisation, vous pouvez demander manuellement chaque permission en utilisant `PermissionsAndroid.request` : ```js import { PermissionsAndroid } from 'react-native'; // Mobile readers using Bluetooth connection require BLUETOOTH_CONNECT, BLUETOOTH_SCAN, and ACCESS_FINE_LOCATION. // This example shows the pattern for requesting one permission. const granted = await PermissionsAndroid.request( PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION, { title: 'Location Permission', message: 'Stripe Terminal needs access to your location', buttonPositive: 'Accept', }, ); if (granted === PermissionsAndroid.RESULTS.GRANTED) { console.log('Location permission granted'); } else { console.error('Location permission denied'); } ``` ### Manifeste Pour garantir une compatibilité avec Android 12 et les versions ultérieures, veillez à ajouter `android:exported="true"` à `AndroidManifest.xml` : ```xml ``` Pour plus de contexte concernant les modifications apportées dans la version Android 12, consultez la [documentation Android relative à l’exportation de composants plus sécurisée](https://developer.android.com/about/versions/12/behavior-changes-12#exported). Pour les appareils sous Android 11 ou version antérieure, vous devez également activer les autorisations via le manifeste : ```xml ``` #### Expo > Ce package ne peut pas être utilisé dans l’application « Expo Go » car il nécessite un [code natif personnalisé](https://docs.expo.io/workflow/customizing/). Vous devez utiliser `npx expo prebuild` pour générer les projets natifs et exécuter votre application avec `npx expo run:ios` ou `npx expo run:android`. #### iOS ### Configuration du SDK Après l’[installation](https://docs.stripe.com/terminal/payments/setup-integration.md#installation) du SDK, ajoutez le [plugin de configuration](https://docs.expo.io/guides/config-plugins/) au tableau [plugins](https://docs.expo.io/versions/latest/config/app/#plugins) de votre `app.json` ou `app.config.js` : Définissez les options de configuration suivantes, en fonction de votre type de lecteur : - `localNetworkUsagePermission` - Obligatoire pour les lecteurs intelligents utilisant une connexion LAN - `appDelegate` - Obligatoire pour Tap to Pay sur Android - `tapToPayCheck` - Active la vérification de la compatibilité Tap to Pay ```json { "expo": { "plugins": [ [ "@stripe/stripe-terminal-react-native", { "bluetoothBackgroundMode": true, "locationWhenInUsePermission": "Location access is required to accept payments.", "bluetoothPeripheralPermission": "Bluetooth access is required to connect to supported bluetooth card readers.", "bluetoothAlwaysUsagePermission": "This app uses Bluetooth to connect to supported card readers.", "localNetworkUsagePermission": "This app uses the local WiFi network to connect to supported card readers.", "appDelegate": true, "tapToPayCheck": true } ] ] } } ``` ### Créer Ensuite, recréez votre application comme décrit dans le guide consacré à l’[ajout de code natif personnalisé](https://docs.expo.io/workflow/customizing/) avec : ```bash npx expo prebuild ``` puis : ```bash npx expo run:ios ``` > Si vous utilisez Tap to Pay sur iPhone, vous devez [demander et configurer](https://developer.apple.com/documentation/proximityreader/setting-up-the-entitlement-for-tap-to-pay-on-iphone) le droit de développement Tap to Pay sur iPhone à partir de votre compte Apple Developer. #### Android ### Autorisations Le SDK Stripe Terminal nécessite les autorisations Android suivantes pour fonctionner correctement : - `PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT` - `PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN` - `PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION` Utilisez la fonction utilitaire `requestNeededAndroidPermissions` pour demander automatiquement toutes les autorisations requises avant d’initialiser le SDK Terminal : ```js import { requestNeededAndroidPermissions } from '@stripe/stripe-terminal-react-native'; try { const granted = await requestNeededAndroidPermissions({ accessFineLocation: { title: 'Location Permission', message: 'Stripe Terminal needs access to your location', buttonPositive: 'Accept', }, }); if (granted) { // Initialize the SDK } else { console.error( 'Location and BT services are required to connect to a reader.' ); } } catch (e) { console.error(e); } ``` Sinon, si vous avez besoin d’un contrôle précis sur les demandes d’autorisation, vous pouvez demander manuellement chaque permission en utilisant `PermissionsAndroid.request` : ```js import { PermissionsAndroid } from 'react-native'; // Mobile readers using Bluetooth connection require BLUETOOTH_CONNECT, BLUETOOTH_SCAN, and ACCESS_FINE_LOCATION. // This example shows the pattern for requesting one permission. const granted = await PermissionsAndroid.request( PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION, { title: 'Location Permission', message: 'Stripe Terminal needs access to your location', buttonPositive: 'Accept', }, ); if (granted === PermissionsAndroid.RESULTS.GRANTED) { console.log('Location permission granted'); } else { console.error('Location permission denied'); } ``` ### Configuration du SDK Après l’[installation](https://docs.stripe.com/terminal/payments/setup-integration.md#installation) du SDK, ajoutez le [plugin de configuration](https://docs.expo.io/guides/config-plugins/) au tableau [plugins](https://docs.expo.io/versions/latest/config/app/#plugins) de votre `app.json` ou `app.config.js` : Définissez les options de configuration suivantes, en fonction de votre type de lecteur : - `localNetworkUsagePermission` - Obligatoire pour les lecteurs intelligents utilisant une connexion LAN - `appDelegate` - Obligatoire pour Tap to Pay sur Android - `tapToPayCheck` - Active la vérification de la compatibilité Tap to Pay ```json { "expo": { "plugins": [ [ "@stripe/stripe-terminal-react-native", { "bluetoothBackgroundMode": true, "locationWhenInUsePermission": "Location access is required to accept payments.", "bluetoothPeripheralPermission": "Bluetooth access is required to connect to supported bluetooth card readers.", "bluetoothAlwaysUsagePermission": "This app uses Bluetooth to connect to supported card readers.", "localNetworkUsagePermission": "This app uses the local WiFi network to connect to supported card readers.", "appDelegate": true, "tapToPayCheck": true } ] ] } } ``` #### Créer Ensuite, recréez votre application comme décrit dans le guide consacré à l’[ajout de code natif personnalisé](https://docs.expo.io/workflow/customizing/) avec : ```bash npx expo prebuild ``` puis : ```bash npx expo run:android ``` ## Configurer l'endpoint du token de connexion [Côté serveur] [Côté client] ### Côté serveur Pour se connecter à un lecteur, votre back-end doit donner au SDK la permission d’utiliser le lecteur avec votre compte Stripe en lui fournissant la [clé secrète](https://docs.stripe.com/api/terminal/connection_tokens/object.md#terminal_connection_token_object-secret) d’un [ConnectionToken](https://docs.stripe.com/api/terminal/connection_tokens.md). Votre back-end doit créer des tokens de connexion uniquement pour les clients qu’il reconnaît comme fiables. #### curl ```bash curl https://api.stripe.com/v1/terminal/connection_tokens \ -u <>: \ -X "POST" ``` Obtenez la clé secrète à partir du `ConnectionToken` sur votre serveur et transmettez-la côté client. #### Ruby ```ruby post '/connection_token' do token = # ... Create or retrieve the ConnectionToken {secret: token.secret}.to_json end ``` > Le `secret` du `ConnectionToken` vous permet de vous connecter à n’importe quel lecteur Stripe Terminal et de traiter les paiements à l’aide de votre compte Stripe. Veillez à authentifier l’endpoint pour créer des tokens de connexion et à le protéger contre la falsification des requêtes intersites (CSRF). ### Côté client Pour permettre au SDK d’accéder à cet endpoint, créez une fonction de fournisseur de tokens qui demande un `ConnectionToken` à votre back-end. ```js import { StripeTerminalProvider } from '@stripe/stripe-terminal-react-native'; const fetchTokenProvider = async () => { const response = await fetch(`{YOUR BACKEND URL}/connection_token`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, }); const { secret } = await response.json(); return secret; }; ``` Cette fonction est appelée dès lors que le SDK doit s’authentifier auprès de Stripe ou du lecteur. Elle est également appelée lorsqu’un nouveau token est nécessaire pour se connecter à un lecteur (par exemple, lorsque votre application s’est déconnectée du lecteur). Si le SDK n’est pas en mesure de récupérer un nouveau jeton de connexion depuis votre backend, la connexion au lecteur échoue associée à une erreur de votre serveur. > Évitez de mettre en cache ou de coder en dur le token de connexion. Le SDK s’occupe de la gestion complète du cycle de vie du token de connexion. ## Initialiser le SDK [Côté client] Pour commencer, transmettez votre fournisseur de tokens implémenté à l’[étape 3](https://docs.stripe.com/terminal/payments/setup-integration.md#connection-token) à `StripeTerminalProvider` en tant que propriété. ```js import { StripeTerminalProvider } from '@stripe/stripe-terminal-react-native'; function Root() { const fetchTokenProvider = async () => { const response = await fetch(`${API_URL}/connection_token`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, }); const { secret } = await response.json(); return secret; }; return ( ); } ``` En dernière étape, appelez la méthode `initialize` depuis le hook `useStripeTerminal`. > Vous devez appeler la méthode `initialize` depuis un composant imbriqué dans `StripeTerminalProvider` et non depuis le composant qui contient `StripeTerminalProvider`. > > Une fois l’initialisation terminée, vous pouvez utiliser d’autres méthodes du SDK telles que `discoverReaders`, `collectPaymentMethod` et `confirmPaymentIntent`. Si vous tentez d’appeler ces méthodes avant l’initialisation, vous recevrez le message d’erreur suivant : « Veuillez initialiser le SDK Stripe Terminal avant d’effectuer toute action. » ```js function App() { const { initialize } = useStripeTerminal(); useEffect(() => { initialize(); }, []); return ; } ``` ## Mises à jour du SDK Stripe publie régulièrement des mises à jour qui peuvent inclure de nouvelles fonctionnalités, des corrections de bugs et des mises à jour de sécurité. Mettez à jour votre SDK dès qu’une nouvelle version est disponible. Les SDK actuellement disponibles sont les suivants : - [SDK Stripe Terminal Android](https://github.com/stripe/stripe-terminal-android/releases) - [SDK Stripe Terminal iOS](https://github.com/stripe/stripe-terminal-ios/releases) - [SDK Stripe Terminal JavaScript](https://docs.stripe.com/terminal/references/api/js-sdk.md#changelog) - [SDK Stripe Terminal React Native](https://github.com/stripe/stripe-terminal-react-native) ## Prochaines étapes - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=react-native&reader-type=internet) # Apps on Devices > This is a Apps on Devices for when terminal-sdk-platform is apps-on-devices. View the full page at https://docs.stripe.com/terminal/payments/setup-integration?terminal-sdk-platform=apps-on-devices. Utilisez Apps on Devices pour exécuter votre application de point de vente (PDV) avec d’autres applications sur votre appareil. Vous pouvez déployer votre application de PDV sur les lecteurs intelligents Stripe pour fournir une solution tout-en-un ou créer une application de paiement destinée à vos clients, qui sera pilotée par votre PDV exécuté sur un autre appareil. Stripe gère tous les paiements et la conformité avec le SDK Android Stripe Terminal. En savoir plus sur [Apps on Devices](https://docs.stripe.com/terminal/features/apps-on-devices/overview.md). Vous pouvez également consulter l’[application test](https://github.com/stripe-samples/terminal-apps-on-devices) pour découvrir les bonnes pratiques d’intégration, comment collecter et confirmer un paiement et plus encore.