# Se connecter à un lecteur Connectez votre application à un lecteur Stripe Terminal. > Si vous n’avez pas encore choisi de lecteur, comparez les [lecteurs Terminal](https://docs.stripe.com/terminal/payments/setup-reader.md) et sélectionnez celui qui répond le mieux à vos besoins. # Lecteur de simulation > This is a Lecteur de simulation for when terminal-sdk-platform is server-driven and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=simulated. Stripe fournit un lecteur de simulation piloté par serveur pour que vous puissiez développer et tester votre application et simuler des paiements Terminal, sans vous connecter à un appareil réel. ## Créer un lecteur de simulation Pour créer un lecteur simulé, utilisez l’un des codes d’enregistrement désignés (`simulated-wpe`, `simulated-s700`, ou `simulated-s710`) lors de l’enregistrement du lecteur. Ce code d’enregistrement crée un objet lecteur WisePOS E, Stripe S700 ou Stripe S710 simulé, uniquement dans un environnement de test. Vous pouvez enregistrer le lecteur simulé à l’aide de l’API Stripe. ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d "location={{TERMINALLOCATION_ID}}" \ -d registration_code=simulated-wpe ``` Ceci renvoie un objet [Reader](https://docs.stripe.com/api/terminal/readers.md) représentant votre lecteur simulé : ```json { "id": "tmr_xxx", "object": "terminal.reader", "device_sw_version": "2.37.2.0", "device_type": "simulated_wisepos_e", "ip_address": "0.0.0.0", "label": "simulated-wpe-xxx-xxx-xx-xxx", "livemode": false, "location": "tml_xxx", "serial_number": "simulated-wpe-xxx-xxx-xx-xxx", "status": "online" } ``` ## Envoyer une requête à votre lecteur de simulation Le lecteur simulé se comporte comme un lecteur réel. Vous pouvez récupérer ses informations à partir de l’[endpoint du lecteur](https://docs.stripe.com/api/terminal/readers/retrieve.md) : ```curl curl https://api.stripe.com/v1/terminal/readers/tmr_xxx \ -u "<>:" ``` ```json { "id": "tmr_xxx", "object": "terminal.reader", "action": null, "device_sw_version": "2.37.2.0", "device_type": "simulated_wisepos_e", "ip_address": "0.0.0.0", "label": "simulated-wpe-xxx-xxx-xx-xxx", "livemode": false, "location": "tml_xxx", "metadata": { }, "serial_number": "simulated-wpe-xxx-xxx-xx-xxx", "status": "offline" } ``` # Lecteur de simulation > This is a Lecteur de simulation for when terminal-sdk-platform is js and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=simulated. Les SDK et l’intégration pilotée par serveur de Stripe Terminal sont livrés avec un lecteur de carte simulé intégré, ce qui vous permet de développer et de tester votre application sans avoir à vous connecter à du matériel physique. Que votre intégration soit terminée ou que vous soyez en train de la développer, utilisez le lecteur simulé pour émuler tous les flux Terminal dans votre application. Le lecteur virtuel ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez la voir fonctionner lorsque les appels au SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour SDK simulent automatiquement la présentation des cartes si nécessaire. Concernant l’intégration pilotée par serveur, mettez à jour votre intégration pour [simuler la présentation d’une carte](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment). Pour utiliser le lecteur de simulation, appelez [discoverReaders](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers) afin de rechercher des lecteurs, avec l’option `simulated` définie sur `true`. Lorsque `discoverReaders` renvoie un résultat, appelez [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) pour vous connecter au lecteur de simulation. ```javascript // Handler for a "Connect Reader" button async function connectReaderHandler() { const config = {simulated: true}; const discoverResult = await terminal.discoverReaders(config); if (discoverResult.error) { console.log('Failed to discover: ', discoverResult.error); } else if (discoverResult.discoveredReaders.length === 0) { console.log('No available readers.'); } else { // Just select the first reader here. const selectedReader = discoverResult.discoveredReaders[0]; const connectResult = await terminal.connectReader(selectedReader); if (connectResult.error) { console.log('Failed to connect: ', connectResult.error); } else { console.log('Connected to reader: ', connectResult.reader.label); } } } ``` ### Configuration du lecteur de simulation - [setSimulatorConfiguration (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-setsimulatorconfig) Le lecteur de simulation prend en charge une petite partie de la configuration, ce qui vous permet de tester différents flux au sein de votre application de point de vente, par exemple différentes marques de cartes ou des scénarios d’erreur comme un paiement refusé. Pour activer ce comportement, utilisez le code suivant avant de recueillir votre moyen de paiement : ```javascript terminal.setSimulatorConfiguration({testCardNumber: '4242424242424242'}); ``` # Lecteur de simulation > This is a Lecteur de simulation for when terminal-sdk-platform is ios and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=simulated. Les SDK et l’intégration pilotée par serveur de Stripe Terminal sont livrés avec un lecteur de carte simulé intégré, ce qui vous permet de développer et de tester votre application sans avoir à vous connecter à du matériel physique. Que votre intégration soit terminée ou que vous soyez en train de la développer, utilisez le lecteur simulé pour émuler tous les flux Terminal dans votre application. Le lecteur virtuel ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez la voir fonctionner lorsque les appels au SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour SDK simulent automatiquement la présentation des cartes si nécessaire. Concernant l’intégration pilotée par serveur, mettez à jour votre intégration pour [simuler la présentation d’une carte](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment). Pour utiliser le lecteur de simulation, appelez [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) pour rechercher des lecteurs, avec l’option `simulated` définie sur `true`. Lorsque `discoverReaders` renvoie un résultat, appelez [connectReader](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:delegate:completion:) pour vous connecter au lecteur de simulation. Lorsqu’elle se connecte à un lecteur mobile ou à un lecteur Tap to Pay, votre intégration doit inclure le `locationId` dans la configuration de connexion, même pour le lecteur de simulation. Le lecteur de simulation ne pouvant pas être associé à un emplacement réel, fournissez plutôt un `locationId` fictif. ```swift import UIKit import StripeTerminal class DiscoverReadersViewController: UIViewController, DiscoveryDelegate { var discoverCancelable: Cancelable? // ... // Action for a "Discover Readers" button func discoverReadersAction() throws {let config = try BluetoothScanDiscoveryConfigurationBuilder().setSimulated(true).build() self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in if let error = error { print("discoverReaders failed: \(error)") } else { print("discoverReaders succeeded") } } } // ... // MARK: DiscoveryDelegate // This delegate method can get called multiple times throughout the discovery process. // You might want to update a UITableView and display all available readers. // Here, we're automatically connecting to the first reader we discover. func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) { // Select the first reader we discover guard let selectedReader = readers.first else { return } // Since the simulated reader is not associated with a real location, we recommend // specifying its existing mock location. guard let locationId = selectedReader.locationId else { return } // Only connect if we aren't currently connected. guard terminal.connectionStatus == .notConnected || terminal.connectionStatus == .discovering else { return } // Replace 'yourMobileReaderDelegate' with your actual MobileReaderDelegate implementation let mobileReaderDelegate = yourMobileReaderDelegate do { connectionConfig = try BluetoothConnectionConfigurationBuilder( // When connecting to a physical reader, your integration should specify either the // same location as the last connection (selectedReader.locationId) or a new location // of your user's choosing. delegate: mobileReaderDelegate, locationId: locationId ) .setAutoReconnectOnUnexpectedDisconnect(true) // This is optional as it's the default value .build() } catch { // Handle error building the connection configuration return } // Note `readerDelegate` should be provided by your application. // See our Quickstart guide at https://stripe.com/docs/terminal/quickstart // for more example code. Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in if let reader = reader { print("Successfully connected to reader: \(reader)") } else if let error = error { print("connectReader failed: \(error)") } } } } ``` ### Configuration du lecteur de simulation - [SimulatorConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPSimulatorConfiguration.html) Le lecteur de simulation prend en charge une petite partie de la configuration, ce qui vous permet de tester différents flux au sein de votre application de point de vente, par exemple différentes marques de cartes ou des scénarios d’erreur comme un paiement refusé. Pour activer ce comportement, utilisez le code suivant avant de recueillir votre moyen de paiement : #### Swift ```swift let simulatorConfiguration = Terminal.shared.simulatorConfiguration simulatorConfiguration.simulatedCard = SimulatedCard(type: .amex) simulatorConfiguration.simulatedTipAmount = 1000 ``` # Lecteur de simulation > This is a Lecteur de simulation for when terminal-sdk-platform is android and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=simulated. Les SDK et l’intégration pilotée par serveur de Stripe Terminal sont livrés avec un lecteur de carte simulé intégré, ce qui vous permet de développer et de tester votre application sans avoir à vous connecter à du matériel physique. Que votre intégration soit terminée ou que vous soyez en train de la développer, utilisez le lecteur simulé pour émuler tous les flux Terminal dans votre application. Le lecteur virtuel ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez la voir fonctionner lorsque les appels au SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour SDK simulent automatiquement la présentation des cartes si nécessaire. Concernant l’intégration pilotée par serveur, mettez à jour votre intégration pour [simuler la présentation d’une carte](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment). Pour utiliser le lecteur de simulation, appelez [discoverReaders](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) pour rechercher des lecteurs, avec l’option `isSimulated` dans la `DiscoveryConfiguration` choisie définie sur `true`. Lorsque `discoverReaders` renvoie un résultat, appelez [connectReader](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) pour vous connecter au lecteur de simulation. Lorsqu’elle se connecte à un lecteur mobile, votre intégration doit inclure le paramètre `locationId` dans la configuration de connexion, même pour le lecteur de simulation. Le lecteur de simulation ne pouvant pas être associé à un emplacement réel, fournissez plutôt un `locationId` fictif. ```kotlin // Handler for a "Connect Reader" button fun onConnect() { val config = BluetoothDiscoveryConfiguration(timeout = 0, isSimulated = true) Terminal.getInstance().discoverReaders( config, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { // Select the first reader here. val firstReader = readers.first() // Replace 'yourMobileReaderListener' with your actual MobileReaderListener implementation val mobileReaderListener = yourMobileReaderListener val autoReconnectOnUnexpectedDisconnect = true // When connecting to a physical reader, specify either the // same location as the last connection (selectedReader.location?.id) or a new location // of your user's choosing. // // Since the simulated reader isn't associated with a real location, we recommend // specifying its existing mock location. val connectionConfig = BluetoothConnectionConfiguration( locationId = firstReader.location?.id.orEmpty(), autoReconnectOnUnexpectedDisconnect = autoReconnectOnUnexpectedDisconnect, bluetoothReaderListener = mobileReaderListener ) Terminal.getInstance().connectReader( firstReader, connectionConfig, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } }, object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } ``` ### Configuration du lecteur de simulation - [SimulatorConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-simulator-configuration/index.html) Le lecteur de simulation prend en charge une petite partie de la configuration, ce qui vous permet de tester différents flux au sein de votre application de point de vente, par exemple différentes marques de cartes ou des scénarios d’erreur comme un paiement refusé. Pour activer ce comportement, utilisez le code suivant avant de recueillir votre moyen de paiement : #### Kotlin ```kotlin val simulatedFixedTipAmount = 1000L; val simulatorConfig = SimulatorConfiguration( simulatedCard = SimulatedCard(SimulatedCardType.AMEX), simulatedTipAmount = simulatedFixedTipAmount ); Terminal.getInstance().setSimulatorConfiguration(simulatorConfig); ``` # Lecteur de simulation > This is a Lecteur de simulation for when terminal-sdk-platform is react-native and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=simulated. Les SDK et l’intégration pilotée par serveur de Stripe Terminal sont livrés avec un lecteur de carte simulé intégré, ce qui vous permet de développer et de tester votre application sans avoir à vous connecter à du matériel physique. Que votre intégration soit terminée ou que vous soyez en train de la développer, utilisez le lecteur simulé pour émuler tous les flux Terminal dans votre application. Le lecteur virtuel ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez la voir fonctionner lorsque les appels au SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour SDK simulent automatiquement la présentation des cartes si nécessaire. Concernant l’intégration pilotée par serveur, mettez à jour votre intégration pour [simuler la présentation d’une carte](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment). Pour utiliser le lecteur simulez, appelez [discoverReaders](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) pour rechercher des lecteurs, avec l’option `simulated` définie sur `true`. Lorsque le rappel `onUpdateDiscoveredReaders` est appelé avec un tableau de lecteurs comme argument, appelez [connectReader](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) pour vous connecter au lecteur simulé. Lorsqu’elle se connecte à un lecteur mobile ou à un lecteur TapToPay, votre intégration doit inclure le `locationId` dans la configuration de connexion, même pour le lecteur de simulation. Le lecteur de simulation ne pouvant pas être associé à un emplacement réel, fournissez plutôt un `locationId` fictif. ```js function DiscoverReadersScreen() { const { discoverReaders, connectReader, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: (readers) => { // After the SDK discovers a reader, your app can connect to it. // Here, we're automatically connecting to the first discovered reader. handleConnectBluetoothReader(readers[0]); }, }); useEffect(() => { handleDiscoverReaders(); }, []); const handleDiscoverReaders = async () => { // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method // within the `useStripeTerminal` hook. const { error } = await discoverReaders({ discoveryMethod: 'bluetoothScan', simulated: true, }); if (error) { Alert.alert( 'Discover readers error: ', `${error.code}, ${error.message}` ); } }; const handleConnectBluetoothReader = async (discoveredReader: Reader.Type) => { const { reader, error } = await connectReader({ discoveryMethod: 'bluetoothScan', reader: discoveredReader, // Since the simulated reader is not associated with a real location, we recommend // specifying its existing mock location. locationId: discoveredReader.locationId, }); if (error) { console.log('connectReader error', error); return; } console.log('Reader connected successfully', reader); }; return ; } ``` ### Configuration du lecteur de simulation - [setSimulatedCard (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#setSimulatedCard) Le lecteur de simulation prend en charge une petite partie de la configuration, ce qui vous permet de tester différents flux au sein de votre application de point de vente, par exemple différentes marques de cartes ou des scénarios d’erreur comme un paiement refusé. Pour activer ce comportement, utilisez le code suivant avant de recueillir votre moyen de paiement : ```js const { error } = await setSimulatedCard('4242424242424242'); if (error) { // Placeholder for handling exception } // Placeholder for handling successful operation ``` # Lecteurs Bluetooth > This is a Lecteurs Bluetooth for when terminal-sdk-platform is ios and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=bluetooth. Les lecteurs connectés par Bluetooth sont des appareils Bluetooth LE. Ils collectent les informations de paiement mais s’appuient sur un appareil mobile associé pour la communication avec Stripe. Suivez ces étapes pour connecter votre application à un lecteur de terminal à l’aide du Bluetooth : 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) > N’utilisez pas des paramètres d’appareil mobile pour associer votre lecteur. L’association du lecteur via les paramètres de l’appareil empêche sa connexion à votre application. ## Détecter les lecteurs [Côté client] - [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) - [BluetoothScanDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothScanDiscoveryConfiguration.html) Pour commencer, assurez-vous que votre lecteur est sous tension et à proximité. Puis, à partir de votre application, recherchez les lecteurs connectés par Bluetooth disponibles à proximité avec la méthode `discoverReaders`, à l’aide de la méthode `BluetoothScanDiscoveryConfiguration`. #### Swift ```swift import StripeTerminal class DiscoverReadersViewController: UIViewController, DiscoveryDelegate { var discoverCancelable: Cancelable? // ... // Action for a "Discover Readers" button func discoverReadersAction() throws { let config = try BluetoothScanDiscoveryConfigurationBuilder().build() // In addition to Terminal's completion block methods, Swift async alternatives are available. // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in if let error = error { print("discoverReaders failed: \(error)") } else { print("discoverReaders succeeded") } } } // ... // MARK: DiscoveryDelegate func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) { // In your app, display the discovered readers to the user. // Call `connectReader` after the user selects a reader to connect to. } } ``` #### Proximité Bluetooth * (BBPOS Chipper 2X BT uniquement) Les filtres de proximité Bluetooth analysent les résultats pour renvoyer le lecteur le plus proche. Des voyants multicolores clignotent alors sur le lecteur détecté, ce qui permet à votre utilisateur de l’identifier facilement parmi de nombreux autres lecteurs. Une fois que le SDK a détecté un lecteur, il ne se connectera pas à un lecteur plus proche, à moins de désactiver le lecteur détecté. Notez que lorsque vous utilisez la proximité Bluetooth, le SDK renvoie deux fois le lecteur à votre application. La première fois, votre application reçoit un objet `Reader` contenant uniquement le numéro de série du lecteur. Après un bref délai, votre application reçoit le même objet `Reader` comportant de nouvelles informations, telles que le niveau de la batterie du lecteur. Nous vous recommandons d’afficher le lecteur détecté dans l’interface utilisateur de votre application. Cela permet à l’utilisateur de confirmer la connexion au lecteur ou de l’annuler s’il ne souhaite pas utiliser ce lecteur. #### Scan Bluetooth Le scan Bluetooth recherche tous les lecteurs les plus proches et renvoie à votre application une liste de lecteurs disponibles. Au fur et à mesure que le processus de recherche avance, le SDK continue à invoquer la méthode `DiscoveryDelegate.didUpdateDiscoveredReaders` avec la dernière liste des lecteurs les plus proches. Au cours du processus de détection, le `SCPConnectionStatus` du Terminal passe à l’état `SCPConnectionStatus.SCPConnectionStatusDiscovering`. La méthode de détection Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de détection. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur quand aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste de lecteurs découverts avec des numéros de série mise à jour automatiquement afin d’aider les utilisateurs à identifier leur lecteur mobile. La propriété `label` n’est pas renseignée pour les lecteurs mobiles lors de la découverte du lecteur. Si vous avez besoin d’afficher des surnoms pour les lecteurs, maintenez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Couplage Bluetooth Afin d’améliorer la sécurité et de se conformer à la réglementation européenne, Stripe utilise depuis novembre 2025 le processus de couplage Bluetooth par comparaison numérique pour les lecteurs de carte WisePad 3. Le processus de comparaison numérique vous oblige à vérifier une clé d’accès à la fois sur votre lecteur de carte et sur votre terminal de paiement lors du couplage. Après avoir mis à jour votre appareil avec la [dernière version du logiciel](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), suivez ces étapes lorsque vous connectez votre WisePad 3 à une nouvelle application mobile. Une fois que votre terminal de paiement a détecté et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond sur le WisePad 3 et sur le terminal de paiement. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Couple** sur votre terminal de point de vente. > #### Remarque > > Vous ne devez effectuer le couplage par comparaison numérique que lorsque vous couplez un WisePad 3 avec un nouveau terminal de point de vente ou lorsque vous le recouplez avec un terminal de point de vente existant « oublié ». ## Se connecter à un lecteur [Côté client] - [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:) - [BluetoothConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothConnectionConfiguration.html) Pour vous connecter à un lecteur détecté, appelez la méthode `connectReader` depuis votre application. À la connexion, vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md). Pour ce faire, créez et utilisez une configuration `BluetoothConnectionConfiguration` avec le `locationId` réglé sur l’ID de l’emplacement à associer lors de la connexion. #### Swift ```swift // Call `connectReader` with the selected reader and a connection config // to register to a location as set by your app. let connectionConfig: BluetoothConnectionConfiguration do { connectionConfig = try BluetoothConnectionConfigurationBuilder(delegate: yourMobileReaderDelegate, locationId: ""{{LOCATION_ID}}"") .build() } catch { // Handle the error building the connection configuration return } Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in if let reader = reader { print("Successfully connected to reader: \(reader)") } else if let error = error { print("connectReader failed: \(error)") } } ``` Pour que votre application fonctionne en arrière-plan et reste connectée au lecteur, [configurez-la](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios#configure) pour inclure le mode d’arrière-plan. > #### Utiliser le mode veille > > Ne programmez pas votre application pour appeler `disconnectReader` afin d’économiser de l’énergie. Le lecteur assure une gestion efficace de l’alimentation à l’aide de son mode veille. ## Gérer les déconnexions des lecteurs - [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html) - [DisconnectReason (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPDisconnectReason.html) Des déconnexions du lecteur peuvent parfois se produire entre votre application et le lecteur. Par exemple, le lecteur peut se déconnecter de votre application si le câble USB qui le relie à votre appareil est déconnectéil est hors de portée ou sa batterie est déchargée. Vous pouvez simuler une déconnexion inattendue pendant le test en éteignant le lecteur. Le `MobileReaderDelegate` inclut une méthode `reader:didDisconnect:` qui fournit à votre application le `DisconnectReason` afin de vous aider à identifier la raison pour laquelle le lecteur s’est déconnecté. Pour traiter vous-même les déconnexions du lecteur, vous pouvez procéder comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur `false` pendant la connexion. 1. Traitez le rappel de déconnexion pour afficher dans l’application un message avertissant l’utilisateur que le lecteur s’est déconnecté de manière inattendue et lancer la détection et la connexion du lecteur. #### Swift ```swift import StripeTerminal class ReaderViewController: UIViewController, MobileReaderDelegate { override func viewDidLoad() { super.viewDidLoad() // Set the reader delegate when connecting to a reader } // ... func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } } ``` ### Redémarrer le lecteur connecté - [rebootReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)rebootReader:.html) Les lecteurs M2 et BBPOS WisePad 3 de Stripe redémarrent automatiquement après 24 heures de fonctionnement. Vous pouvez cependant forcer le lecteur à redémarrer et réinitialiser sa minuterie de 24 heures à l’aide de l’API `rebootReader`. Après cette action, le lecteur se déconnecte du SDK, puis redémarre. Si vous utilisez la reconnexion automatique, le SDK tente de rétablir la connexion avec le lecteur. #### Swift ```swift Terminal.shared.rebootReader { error in if let error = error { // Placeholder for handling the error } else { // Reboot succeeded and the reader will disconnect. // If your app is using automatic reconnect the reconnect will begin. } } ``` #### Tentative de reconnexion automatique Lorsqu’un lecteur se déconnecte, nous tentons automatiquement une reconnexion par défaut et vous recommandons d’afficher dans votre application des notifications qui indiquent l’état du lecteur tout au long du processus. Pour afficher des notifications dans votre application lors de la reconnexion automatique, procédez comme suit : 1. Implémentez les rappels de reconnexion du lecteur dans le `MobileReaderDelegate`. 1. Transmettez le `MobileReaderDelegate` à votre `BluetoothConnectionConfiguration`. 1. Lorsque le SDK envoie [`reader:didStartReconnect:disconnectReason:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didStartReconnect:disconnectReason:) à votre application, affichez un message indiquant que le lecteur a perdu la connexion et que la reconnexion est en cours. - Vous pouvez utiliser l’objet `Cancelable` pour arrêter la tentative de reconnexion à tout moment. 1. Lorsque le SDK indique que la reconnexion a réussi en envoyant [`readerDidSucceedReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidSucceedReconnect:), affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si le SDK ne peut pas se reconnecter au lecteur et envoie à la fois [`readerDidFailReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidFailReconnect:) et `reader:didDisconnect:`, affichez un message indiquant qu’une déconnexion inattendue s’est produite. #### Swift ```swift import StripeTerminal extension ReaderViewController: MobileReaderDelegate { // MARK: MobileReaderDelegate func reader(_ reader: Reader, didStartReconnect cancelable: Cancelable, disconnectReason: DisconnectReason) { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time } func readerDidSucceedReconnect(_ reader: Reader) { // 2. Notified when reader reconnection succeeds // App is now connected } func readerDidFailReconnect(_ reader: Reader) { // 3. Notified when reader reconnection fails // App is now disconnected } } ``` #### Reconnexion automatique au démarrage de l’application Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous connectez un lecteur, enregistrez son numéro de série dans un emplacement de stockage de données persistant, tel que l’[API UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults) (iOS). 1. Au lancement de votre application, recherchez un numéro de série enregistré dans l’emplacement de stockage persistant des données. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Affichez une interface utilisateur pendant le processus de détection et de connexion pour indiquer qu’une reconnexion automatique est en cours. ## Mettre à jour le logiciel du lecteur [Côté client] - [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html) Votre application doit mettre à jour les lecteurs mobiles pour appliquer les éléments suivants : - des configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - des mises à jour de sécurité L’installation des mises à jour obligatoires se lance lors de la connexion au lecteur. Vous ne pouvez pas utiliser le lecteur tant que la mise à jour n’est pas terminée. > Pour installer des mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque les mises à jour immédiatement nécessaires sont disponibles pour le lecteur, le `MobileReaderDelegate` de l’intégration reçoit le rappel `didStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation de la durée totale de la mise à jour, indiquée par `durationEstimate`. Pendant le processus d’installation, le `connectionStatus` du Terminal passe à `connecting` pendant que la mise à jour s’installe sur le lecteur. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et afficher sa progression dans votre interface utilisateur. Expliquez clairement pourquoi la connexion peut prendre plus de temps que d’habitude. Si le processus de mise à jour requis échoue, Stripe communique l’erreur au `MobileReaderDelegate` avec `didFinishInstallingUpdate`. Vous ne pouvez pas vous reconnecter au lecteur après l’échec d’une mise à jour requise, sauf si les conditions suivantes sont remplies : - Le lecteur exécute la dernière version du logiciel pour l’emplacement au cours des 30 derniers jours. - La version du SDK iOS est supérieure ou égale à la version `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour requise soit incomplète. Lors de la prochaine connexion à ce lecteur, Stripe tente à nouveau d’effectuer la mise à jour requise jusqu’à ce qu’elle soit installée avec succès. #### Swift ```swift import UIKit import StripeTerminal class ReaderViewController: UIViewController, MobileReaderDelegate { // ... // MARK: MobileReaderDelegate func reader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) { // Show UI communicating that a required update has started installing } func reader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) { // Update the progress of the installation } func reader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) { // Report success or failure of the update } // ... } ``` Vous pouvez annuler les mises à jour requises à l’aide de l’objet `Cancelable`, ce qui entraîne également un échec de connexion au lecteur. Vous ne pouvez pas annuler les mises à jour uniquement incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date indiquée, après quoi elles deviennent obligatoires. Le SDK vous informe des mises à jour facultatives via le `MobileReaderDelegate` chaque fois que le lecteur est connecté mais n’effectue pas de transaction. Si une mise à jour facultative est disponible, le `MobileReaderDelegate` de votre application reçoit le rappel `didReportAvailableUpdate` avec l’objet `ReaderSoftwareUpdate` contenant les détails de la mise à jour, y compris : - Temps estimé pour la fin de la mise à jour (`durationEstimate`) - Horodatage après lequel la mise à jour devient obligatoire (`requiredAt`) Dans votre application, signalez aux utilisateurs qu’une mise à jour est disponible et affichez un message les invitant à l’installer. Pour procéder à la mise à jour précédemment signalée avec `didReportAvailableUpdate`, appelez `Terminal.shared.installAvailableUpdate`. La mise à jour disponible est également stockée dans l’objet Reader sous la forme `reader.availableUpdate`. Pendant la durée de la mise à jour, empêchez l’utilisateur de quitter la page de votre application et invitez-le à garder le lecteur sous la main et sous tension jusqu’au terme de l’installation. Nous vous recommandons également d’afficher un indicateur visuel de la progression de la mise à jour. Le `MobileReaderDelegate` rapporte la progression de la mise à jour dans la méthode `didReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, la mise à jour est installée la prochaine fois que le lecteur est connecté. #### Swift ```swift import UIKit import StripeTerminal class ReaderViewController: UIViewController, MobileReaderDelegate { // ... // MARK: MobileReaderDelegate func reader(_ reader: Reader, didReportAvailableUpdate update: ReaderSoftwareUpdate) { // An update is available for the connected reader. Show this update in your application. // Install this update using `Terminal.shared.installAvailableUpdate`. } } ``` Pour savoir comment vérifier si votre application gère les différents types de mises à jour possibles sur un lecteur, consultez la page [Test des mises à jour d’un lecteur](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates). # Lecteurs Bluetooth > This is a Lecteurs Bluetooth for when terminal-sdk-platform is android and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=bluetooth. Les lecteurs connectés par Bluetooth sont des appareils Bluetooth LE. Ils collectent les informations de paiement mais s’appuient sur un appareil mobile associé pour la communication avec Stripe. Suivez ces étapes pour connecter votre application à un lecteur de terminal à l’aide du Bluetooth : 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) > N’utilisez pas des paramètres d’appareil mobile pour associer votre lecteur. L’association du lecteur via les paramètres de l’appareil empêche sa connexion à votre application. ## Détecter les lecteurs [Côté client] - [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) - [BluetoothDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-bluetooth-discovery-configuration/index.html) Pour commencer, assurez-vous que votre lecteur est sous tension et à proximité. Puis, à partir de votre application, recherchez les lecteurs connectés par Bluetooth disponibles à proximité avec la méthode `discoverReaders`, à l’aide de `BluetoothDiscoveryConfiguration`. #### Kotlin ```kotlin class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener { var discoverCancelable: Cancelable? = null // ... // Action for a "Discover Readers" button fun discoverReadersAction() { val timeout = 0 val isSimulated = false val config = BluetoothDiscoveryConfiguration( timeout = timeout, isSimulated = isSimulated ) discoverCancelable = Terminal.getInstance().discoverReaders( config, this, object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } // DiscoveryListener override fun onUpdateDiscoveredReaders(readers: List) { // In your app, display the discovered readers to the user. // Call `connectReader` after the user selects a reader to connect to. } } ``` #### Scan Bluetooth Le scan Bluetooth recherche tous les lecteurs les plus proches et renvoie à votre application une liste de lecteurs disponibles. Au fur et à mesure que le processus de recherche avance, le SDK continue à invoquer la méthode `onUpdateDiscoveredReaders` avec la dernière liste des lecteurs les plus proches. Au cours du processus de détection, le `connectionStatus` du Terminal passe à l’état `ConnectionStatus.DISCOVERING`. La méthode de détection Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de détection. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur quand aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste de lecteurs découverts avec des numéros de série mise à jour automatiquement afin d’aider les utilisateurs à identifier leur lecteur mobile. La propriété `label` n’est pas renseignée pour les lecteurs mobiles lors de la découverte du lecteur. Si vous avez besoin d’afficher des surnoms pour les lecteurs, maintenez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Couplage Bluetooth Afin d’améliorer la sécurité et de se conformer à la réglementation européenne, Stripe utilise depuis novembre 2025 le processus de couplage Bluetooth par comparaison numérique pour les lecteurs de carte WisePad 3. Le processus de comparaison numérique vous oblige à vérifier une clé d’accès à la fois sur votre lecteur de carte et sur votre terminal de paiement lors du couplage. Après avoir mis à jour votre appareil avec la [dernière version du logiciel](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), suivez ces étapes lorsque vous connectez votre WisePad 3 à une nouvelle application mobile. Une fois que votre terminal de paiement a détecté et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond sur le WisePad 3 et sur le terminal de paiement. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Couple** sur votre terminal de point de vente. > #### Remarque > > Vous ne devez effectuer le couplage par comparaison numérique que lorsque vous couplez un WisePad 3 avec un nouveau terminal de point de vente ou lorsque vous le recouplez avec un terminal de point de vente existant « oublié ». ## Se connecter à un lecteur [Côté client] - [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) - [BluetoothConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-bluetooth-connection-configuration/index.html) Pour vous connecter à un lecteur détecté, appelez la méthode `connectReader` depuis votre application. À la connexion, vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md). Pour ce faire, créez et utilisez une configuration `BluetoothConnectionConfiguration` avec le `locationId` réglé sur l’ID de l’emplacement à associer lors de la connexion. #### Kotlin ```kotlin // Implement your MobileReaderListener val mobileReaderListener = yourMobileReaderListener val autoReconnectOnUnexpectedDisconnect = true val connectionConfig = BluetoothConnectionConfiguration( ""{{LOCATION_ID}}"", autoReconnectOnUnexpectedDisconnect, mobileReaderListener ) Terminal.getInstance().connectReader( selectedReader, connectionConfig, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` > #### Utiliser le mode veille > > Ne programmez pas votre application pour appeler `disconnectReader` afin d’économiser de l’énergie. Le lecteur assure une gestion efficace de l’alimentation à l’aide de son mode veille. ## Gérer les déconnexions des lecteurs - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) - [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html) Des déconnexions du lecteur peuvent parfois se produire entre votre application et le lecteur. Par exemple, le lecteur peut se déconnecter de votre application si le câble USB qui le relie à votre appareil est déconnectéil est hors de portée ou sa batterie est déchargée. Vous pouvez simuler une déconnexion inattendue pendant le test en éteignant le lecteur. Le `MobileReaderListener` inclut un rappel `onDisconnect` qui fournit à votre application le `DisconnectReason` afin de vous aider à identifier la raison pour laquelle le lecteur s’est déconnecté. Pour traiter vous-même les déconnexions du lecteur, vous pouvez procéder comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur `false` pendant la connexion. 1. Traitez le rappel de déconnexion pour afficher dans l’application un message avertissant l’utilisateur que le lecteur s’est déconnecté de manière inattendue et lancer la détection et la connexion du lecteur. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onDisconnect(reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } // ... } ``` ### Redémarrer le lecteur connecté - [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html) Les lecteurs M2 et BBPOS WisePad 3 de Stripe redémarrent automatiquement après 24 heures de fonctionnement. Vous pouvez cependant forcer le lecteur à redémarrer et réinitialiser sa minuterie de 24 heures à l’aide de l’API `rebootReader`. Après cette action, le lecteur se déconnecte du SDK, puis redémarre. Si vous utilisez la reconnexion automatique, le SDK tente de rétablir la connexion avec le lecteur. #### Kotlin ```kotlin Terminal.getInstance().rebootReader( object : Callback { override fun onSuccess() { // Reboot succeeded and the reader will disconnect. // If your app is using automatic reconnect the reconnect will begin. } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` #### Tentative de reconnexion automatique Lorsqu’un lecteur se déconnecte, nous tentons automatiquement une reconnexion par défaut et vous recommandons d’afficher dans votre application des notifications qui indiquent l’état du lecteur tout au long du processus. Pour afficher des notifications dans votre application lors de la reconnexion automatique, procédez comme suit : 1. Implémentez les rappels de reconnexion du lecteur dans le `MobileReaderListener`. 1. Transmettez le `MobileReaderListener` à votre `BluetoothConnectionConfiguration`. 1. Lorsque le SDK envoie [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) à votre application, affichez un message indiquant que le lecteur a perdu la connexion et que la reconnexion est en cours. - Vous pouvez utiliser l’objet `Cancelable` pour arrêter la tentative de reconnexion à tout moment. 1. Lorsque le SDK indique que la reconnexion a réussi en envoyant [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html), affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si le SDK ne peut pas se reconnecter au lecteur et envoie à la fois [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) et `onDisconnect`, affichez un message indiquant qu’une déconnexion inattendue s’est produite. #### Kotlin ```kotlin class CustomMobileReaderListener : MobileReaderListener { // ... override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time } override fun onReaderReconnectSucceeded(reader: Reader) { // 2. Notified when reader reconnection succeeds // App is now connected } override fun onReaderReconnectFailed(reader: Reader) { // 3. Notified when reader reconnection fails // App is now disconnected } // ... } ``` #### Reconnexion automatique au démarrage de l’application Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android). 1. Au lancement de votre application, recherchez un numéro de série enregistré dans l’emplacement de stockage persistant des données. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Affichez une interface utilisateur pendant le processus de détection et de connexion pour indiquer qu’une reconnexion automatique est en cours. ## Mettre à jour le logiciel du lecteur [Côté client] - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Votre application doit mettre à jour les lecteurs mobiles pour appliquer les éléments suivants : - des configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - des mises à jour de sécurité L’installation des mises à jour obligatoires se lance lors de la connexion au lecteur. Vous ne pouvez pas utiliser le lecteur tant que la mise à jour n’est pas terminée. > Pour installer des mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque les mises à jour immédiatement nécessaires sont disponibles pour le lecteur, le `MobileReaderListener` de l’intégration reçoit `onStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation de la durée totale de la mise à jour, indiquée par `durationEstimate`. Pendant le processus d’installation, le `connectionStatus` du Terminal passe à `ConnectionStatus.CONNECTING` pendant que la mise à jour s’installe sur le lecteur. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et afficher sa progression dans votre interface utilisateur. Expliquez clairement pourquoi la connexion peut prendre plus de temps que d’habitude. Si le processus de mise à jour requis échoue, Stripe communique l’erreur au `MobileReaderListener` avec `onFinishInstallingUpdate`. Vous ne pouvez pas vous reconnecter au lecteur après l’échec d’une mise à jour requise, sauf si les conditions suivantes sont remplies : - Le lecteur exécute la dernière version du logiciel pour l’emplacement au cours des 30 derniers jours. - La version du SDK Android est supérieure ou égale à la version `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour requise soit incomplète. Lors de la prochaine connexion à ce lecteur, Stripe tente à nouveau d’effectuer la mise à jour requise jusqu’à ce qu’elle soit installée avec succès. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) { // Show UI communicating that a required update has started installing } override fun onReportReaderSoftwareUpdateProgress(progress: Float) { // Update the progress of the installation } override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) { // Report success or failure of the update } // ... } ``` Vous pouvez annuler les mises à jour requises à l’aide de l’objet `Cancelable`, ce qui entraîne également un échec de connexion au lecteur. Vous ne pouvez pas annuler les mises à jour uniquement incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date indiquée, après quoi elles deviennent obligatoires. Le SDK vous informe des mises à jour facultatives via le `MobileReaderListener` chaque fois que le lecteur est connecté mais n’effectue pas de transaction. Si une mise à jour facultative est disponible, le `MobileReaderListener` de votre application reçoit le rappel `onReportAvailableUpdate` avec l’objet `ReaderSoftwareUpdate` contenant les détails de la mise à jour, y compris : - Temps estimé pour la fin de la mise à jour (`durationEstimate`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, signalez aux utilisateurs qu’une mise à jour est disponible et affichez un message les invitant à l’installer. Pour procéder à la mise à jour précédemment signalée avec `onReportAvailableUpdate`, appelez `Terminal.getInstance().installAvailableUpdate`. La mise à jour disponible est également stockée dans l’objet Reader sous la forme `reader.availableUpdate`. Pendant la durée de la mise à jour, empêchez l’utilisateur de quitter la page de votre application et invitez-le à garder le lecteur sous la main et sous tension jusqu’au terme de l’installation. Nous vous recommandons également d’afficher un indicateur visuel de la progression de la mise à jour. Le `MobileReaderListener` rapporte la progression de la mise à jour dans la méthode `onReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, la mise à jour est installée la prochaine fois que le lecteur est connecté. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) { // An update is available for the connected reader. Show this update in your application. // Install this update using `Terminal.getInstance().installAvailableUpdate`. } // ... } ``` Pour savoir comment vérifier si votre application gère les différents types de mises à jour possibles sur un lecteur, consultez la page [Test des mises à jour d’un lecteur](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates). # Lecteurs Bluetooth > This is a Lecteurs Bluetooth for when terminal-sdk-platform is react-native and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=bluetooth. Les lecteurs connectés par Bluetooth sont des appareils Bluetooth LE. Ils collectent les informations de paiement mais s’appuient sur un appareil mobile associé pour la communication avec Stripe. Suivez ces étapes pour connecter votre application à un lecteur de terminal à l’aide du Bluetooth : 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) > N’utilisez pas des paramètres d’appareil mobile pour associer votre lecteur. L’association du lecteur via les paramètres de l’appareil empêche sa connexion à votre application. ## Détecter les lecteurs [Côté client] - [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) Pour commencer, assurez-vous que votre lecteur est sous tension et à proximité. Puis, à partir de votre application, recherchez les lecteurs connectés par Bluetooth disponibles à proximité avec la méthode `discoverReaders`, en définissant `discoveryMethod` sur `bluetoothScan`. ```js function DiscoverReadersScreen() { const { discoverReaders, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: (readers) => { // After the SDK discovers a reader, your app can connect to it. }, }); useEffect(() => { handleDiscoverReaders(); }, [discoverReaders]); const handleDiscoverReaders = async () => { // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method // within the `useStripeTerminal` hook. const { error } = await discoverReaders({ discoveryMethod: 'bluetoothScan', }); if (error) { Alert.alert( 'Discover readers error: ', `${error.code}, ${error.message}` ); } }; return ; } ``` #### Scan Bluetooth Le scan Bluetooth recherche tous les lecteurs les plus proches et renvoie à votre application une liste de lecteurs disponibles. Au fur et à mesure que le processus de recherche avance, le SDK continue à invoquer `onUpdateDiscoveredReaders` dans le hook `useStripeTerminal` avec la dernière liste des lecteurs les plus proches. La méthode de détection Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de détection. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur quand aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste de lecteurs découverts avec des numéros de série mise à jour automatiquement afin d’aider les utilisateurs à identifier leur lecteur mobile. La propriété `label` n’est pas renseignée pour les lecteurs mobiles lors de la découverte du lecteur. Si vous avez besoin d’afficher des surnoms pour les lecteurs, maintenez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Couplage Bluetooth Afin d’améliorer la sécurité et de se conformer à la réglementation européenne, Stripe utilise depuis novembre 2025 le processus de couplage Bluetooth par comparaison numérique pour les lecteurs de carte WisePad 3. Le processus de comparaison numérique vous oblige à vérifier une clé d’accès à la fois sur votre lecteur de carte et sur votre terminal de paiement lors du couplage. Après avoir mis à jour votre appareil avec la [dernière version du logiciel](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), suivez ces étapes lorsque vous connectez votre WisePad 3 à une nouvelle application mobile. Une fois que votre terminal de paiement a détecté et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond sur le WisePad 3 et sur le terminal de paiement. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Couple** sur votre terminal de point de vente. > #### Remarque > > Vous ne devez effectuer le couplage par comparaison numérique que lorsque vous couplez un WisePad 3 avec un nouveau terminal de point de vente ou lorsque vous le recouplez avec un terminal de point de vente existant « oublié ». ## Se connecter à un lecteur [Côté client] - [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) Pour vous connecter à un lecteur détecté, appelez la méthode `connectReader` depuis votre application. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, assurez-vous que `locationId` est défini sur l’ID de l’emplacement approprié lors de la connexion. ```js const handleConnectBluetoothReader = async (id) => { const { reader, error } = await connectReader({ discoveryMethod: 'bluetoothScan', reader: selectedReader, locationId: {{LOCATION_ID}}, }); if (error) { console.log('connectReader error', error); return; } console.log('Reader connected successfully', reader); }; ``` > #### Utiliser le mode veille > > Ne programmez pas votre application pour appeler `disconnectReader` afin d’économiser de l’énergie. Le lecteur assure une gestion efficace de l’alimentation à l’aide de son mode veille. ## Gérer les déconnexions des lecteurs - [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT) - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) - [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason) Des déconnexions du lecteur peuvent parfois se produire entre votre application et le lecteur. Par exemple, le lecteur peut se déconnecter de votre application si le câble USB qui le relie à votre appareil est déconnectéil est hors de portée ou sa batterie est déchargée. Vous pouvez simuler une déconnexion inattendue pendant le test en éteignant le lecteur. `UserCallbacks` comprend un `onDidDisconnect` qui fournit à votre application le `DisconnectReason` qui permet d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour traiter vous-même les déconnexions du lecteur, vous pouvez procéder comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur `false` pendant la connexion. 1. Traitez le rappel de déconnexion pour afficher dans l’application un message avertissant l’utilisateur que le lecteur s’est déconnecté de manière inattendue et lancer la détection et la connexion du lecteur. ```js const terminal = useStripeTerminal({ onDidDisconnect: (result) => { // Consider displaying a UI to notify the user and start rediscovering readers }, }); ``` ### Redémarrer le lecteur connecté - [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader) Les lecteurs M2 et BBPOS WisePad 3 de Stripe redémarrent automatiquement après 24 heures de fonctionnement. Vous pouvez cependant forcer le lecteur à redémarrer et réinitialiser sa minuterie de 24 heures à l’aide de l’API `rebootReader`. Après cette action, le lecteur se déconnecte du SDK, puis redémarre. Si vous utilisez la reconnexion automatique, le SDK tente de rétablir la connexion avec le lecteur. ```js const { error } = await rebootReader(); if (error) { console.log('rebootReader error:', error); return; } console.log('rebootReader succeeded'); ``` #### Tentative de reconnexion automatique Lorsqu’un lecteur se déconnecte, nous tentons automatiquement une reconnexion par défaut et vous recommandons d’afficher dans votre application des notifications qui indiquent l’état du lecteur tout au long du processus. Pour afficher des notifications dans votre application lors de la reconnexion automatique, procédez comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur true dans `ConnectBluetoothReaderParams`. 1. Mettez en œuvre les rappels de reconnexion automatique qui se trouvent dans les `UserCallbacks`. 1. Lorsque le SDK envoie `onDidStartReaderReconnect` à votre application, affichez un message indiquant que le lecteur a perdu la connexion et que la reconnexion est en cours. - Vous pouvez utiliser `cancelReaderReconnection` pour interrompre la tentative de reconnexion à tout moment. 1. Lorsque le SDK indique que la reconnexion a réussi en envoyant `onDidSucceedReaderReconnect`, affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si le SDK ne peut pas se reconnecter au lecteur et envoie `onDidFailReaderReconnect`, affichez un message indiquant qu’une déconnexion inattendue s’est produite. #### Reconnexion automatique au démarrage de l’application Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native). 1. Au lancement de votre application, recherchez un numéro de série enregistré dans l’emplacement de stockage persistant des données. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Affichez une interface utilisateur pendant le processus de détection et de connexion pour indiquer qu’une reconnexion automatique est en cours. ## Mettre à jour le logiciel du lecteur [Côté client] - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Votre application doit mettre à jour les lecteurs mobiles pour appliquer les éléments suivants : - des configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - des mises à jour de sécurité L’installation des mises à jour obligatoires se lance lors de la connexion au lecteur. Vous ne pouvez pas utiliser le lecteur tant que la mise à jour n’est pas terminée. > Pour installer des mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque les mises à jour immédiatement nécessaires sont disponibles pour le lecteur, l’intégration reçoit `onDidStartInstallingUpdate` du hook `useStripeTerminal` avec un `Reader.SoftwareUpdate`. Le `Reader.SoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation de la durée totale de la mise à jour, indiquée par `estimatedUpdateTime`. Pendant le processus d’installation, le `connectionStatus` du Terminal passe à `"connecting"` pendant que la mise à jour s’installe sur le lecteur. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et afficher sa progression dans votre interface utilisateur. Expliquez clairement pourquoi la connexion peut prendre plus de temps que d’habitude. Si le processus de mise à jour requis échoue, Stripe communique l’erreur au hook `useStripeTerminal` avec `onDidFinishInstallingUpdate`. Vous ne pouvez pas vous reconnecter au lecteur après l’échec d’une mise à jour requise, sauf si les conditions suivantes sont remplies : - Le lecteur exécute la dernière version du logiciel pour l’emplacement au cours des 30 derniers jours. - La version du SDK React Native est supérieure ou égale à la version `0.0.1-beta.18`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour requise soit incomplète. Lors de la prochaine connexion à ce lecteur, Stripe tente à nouveau d’effectuer la mise à jour requise jusqu’à ce qu’elle soit installée avec succès. ```js const terminal = useStripeTerminal({ onDidReportReaderSoftwareUpdateProgress: (progress) => { setCurrentProgress((Number(progress) * 100).toFixed(0).toString()); }, onDidFinishInstallingUpdate: ({ error }) => { }, onDidStartInstallingUpdate: (update) => { }, }); ``` Vous pouvez annuler les mises à jour requises à l’aide de l’API `cancelInstallingUpdate`, ce qui entraîne également un échec de la connexion au lecteur. Vous ne pouvez pas annuler les mises à jour uniquement incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date indiquée, après quoi elles deviennent obligatoires. Le SDK vous informe des mises à jour facultatives avec le rappel `onDidReportAvailableUpdate` du hook `useStripeTerminal` chaque fois que le lecteur est connecté mais n’effectue pas de transaction. Si une mise à jour facultative est disponible, le hook `useStripeTerminal` de votre application reçoit le rappel `onDidReportAvailableUpdate` avec l’objet `SoftwareUpdate` contenant les détails de la mise à jour, notamment les informations suivantes : - Temps estimé pour l’exécution de la mise à jour (`estimatedUpdateTime`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, signalez aux utilisateurs qu’une mise à jour est disponible et affichez un message les invitant à l’installer. Pour procéder à la mise à jour précédemment signalée avec `onDidReportAvailableUpdate`, appelez `installAvailableUpdate`à partir du hook `useStripeTerminal`. La mise à jour disponible est également stockée dans l’objet Reader sous la forme `reader.availableUpdate`. Pendant la durée de la mise à jour, empêchez l’utilisateur de quitter la page de votre application et invitez-le à garder le lecteur sous la main et sous tension jusqu’au terme de l’installation. Nous vous recommandons également d’afficher un indicateur visuel de la progression de la mise à jour. Le hook `useStripeTerminal` rapporte la progression de la mise à jour dans la méthode `onDidReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, la mise à jour est installée la prochaine fois que le lecteur est connecté. ```js const terminal = useStripeTerminal({ onDidReportAvailableUpdate: (update) => { // An update is available for the connected reader. Show this update in your application. // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook. }, }); ``` Pour savoir comment vérifier si votre application gère les différents types de mises à jour possibles sur un lecteur, consultez la page [Test des mises à jour d’un lecteur](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates). # Lecteurs USB > This is a Lecteurs USB for when terminal-sdk-platform is android and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=usb. Utilisez le SDK 3.0.0 Android (ou version ultérieure) du Terminal Stripe afin de prendre en charge les connexions USB pour les lecteurs [Reader M2 de Stripe](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) et [BBPOS WisePad 3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md). Vous devez utiliser un câble USB qui prend en charge à la fois le transfert de données et la charge, comme le câble USB 2.0 qui est inclus avec le lecteur Stripe M2 et le BBPOS WisePad 3. Si le câble fourni avec votre lecteur de terminal ne permet que la charge, utilisez un câble USB 2.0 tiers qui peut transférer des données. Pour connecter votre application à un lecteur Terminal à l’aide du câble USB : 1. [Détection de lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers). 1. [Connexion à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader). ## Détecter les lecteurs [Côté client] - [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) - [UsbDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-usb-discovery-configuration/index.html) Assurez-vous que le lecteur est sous tension et connecté avec un câble USB 2.0 à l’appareil exécutant votre application, et que l’accès au lecteur connecté en USB a été autorisé. Si vous branchez le lecteur pour la première fois, une invite du système Android s’affiche pour vous demander de vous connecter au lecteur. Vous pouvez cocher la case « Toujours ouvert » pour ouvrir votre application sans demande lorsqu’elle est connectée à un lecteur. Puis, à partir de votre application, recherchez le lecteur connecté avec la méthode `discoverReaders`, à l’aide de `UsbDiscoveryConfiguration`. #### Kotlin ```kotlin class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener { // ... var discoverCancelable: Cancelable? = null // Action for a "Discover Readers" button fun discoverReadersAction() { val timeout = 0 val isSimulated = false val config = UsbDiscoveryConfiguration( timeout = timeout, isSimulated = isSimulated ) Terminal.getInstance().discoverReaders( config, this, object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } override fun onUpdateDiscoveredReaders(readers: List) { // In your app, display the discovered readers to the user. // Call `connectReader` after the user selects a reader to connect to. } // ... } ``` ## Se connecter à un lecteur [Côté client] - [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) - [UsbConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-usb-connection-configuration/index.html) Pour vous connecter à un lecteur détecté, appelez la méthode `connectReader` depuis votre application. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, créez et utilisez une `UsbConnectionConfiguration` avec le `locationId` défini sur l’ID de l’emplacement approprié lors de la connexion. #### Kotlin ```kotlin // Implement your MobileReaderListener val mobileReaderListener = yourMobileReaderListener val autoReconnectOnUnexpectedDisconnect = true val connectionConfig = UsbConnectionConfiguration( ""{{LOCATION_ID}}"", autoReconnectOnUnexpectedDisconnect, mobileReaderListener ) Terminal.getInstance().connectReader( selectedReader, connectionConfig, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` > #### Utiliser le mode veille > > Ne programmez pas votre application pour appeler `disconnectReader` afin d’économiser de l’énergie. Le lecteur assure une gestion efficace de l’alimentation à l’aide de son mode veille. ## Gérer les déconnexions des lecteurs - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) - [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html) Des déconnexions du lecteur peuvent parfois se produire entre votre application et le lecteur. Par exemple, le lecteur peut se déconnecter de votre application si le câble USB qui le relie à votre appareil est déconnectéil est hors de portée ou sa batterie est déchargée. Vous pouvez simuler une déconnexion inattendue pendant le test en éteignant le lecteur. Le `MobileReaderListener` inclut un rappel `onDisconnect` qui fournit à votre application le `DisconnectReason` afin de vous aider à identifier la raison pour laquelle le lecteur s’est déconnecté. Pour traiter vous-même les déconnexions du lecteur, vous pouvez procéder comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur `false` pendant la connexion. 1. Traitez le rappel de déconnexion pour afficher dans l’application un message avertissant l’utilisateur que le lecteur s’est déconnecté de manière inattendue et lancer la détection et la connexion du lecteur. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onDisconnect(reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } // ... } ``` ### Redémarrer le lecteur connecté - [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html) Les lecteurs M2 et BBPOS WisePad 3 de Stripe redémarrent automatiquement après 24 heures de fonctionnement. Vous pouvez cependant forcer le lecteur à redémarrer et réinitialiser sa minuterie de 24 heures à l’aide de l’API `rebootReader`. Après cette action, le lecteur se déconnecte du SDK, puis redémarre. Si vous utilisez la reconnexion automatique, le SDK tente de rétablir la connexion avec le lecteur. #### Kotlin ```kotlin Terminal.getInstance().rebootReader( object : Callback { override fun onSuccess() { // Reboot succeeded and the reader will disconnect. // If your app is using automatic reconnect the reconnect will begin. } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` #### Tentative de reconnexion automatique Lorsqu’un lecteur se déconnecte, nous tentons automatiquement une reconnexion par défaut et vous recommandons d’afficher dans votre application des notifications qui indiquent l’état du lecteur tout au long du processus. Pour afficher des notifications dans votre application lors de la reconnexion automatique, procédez comme suit : 1. Implémentez les rappels de reconnexion du lecteur dans le `MobileReaderListener`. 1. Transmettez le `MobileReaderListener` à votre `UsbConnectionConfiguration`. 1. Lorsque le SDK envoie [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) à votre application, affichez un message indiquant que le lecteur a perdu la connexion et que la reconnexion est en cours. - Vous pouvez utiliser l’objet `Cancelable` pour arrêter la tentative de reconnexion à tout moment. 1. Lorsque le SDK indique que la reconnexion a réussi en envoyant [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html), affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si le SDK ne peut pas se reconnecter au lecteur et envoie à la fois [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) et `onDisconnect`, affichez un message indiquant qu’une déconnexion inattendue s’est produite. #### Kotlin ```kotlin class CustomMobileReaderListener : MobileReaderListener { // ... override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time } override fun onReaderReconnectSucceeded(reader: Reader) { // 2. Notified when reader reconnection succeeds // App is now connected } override fun onReaderReconnectFailed(reader: Reader) { // 3. Notified when reader reconnection fails // App is now disconnected } // ... } ``` #### Reconnexion automatique au démarrage de l’application Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android). 1. Au lancement de votre application, recherchez un numéro de série enregistré dans l’emplacement de stockage persistant des données. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Affichez une interface utilisateur pendant le processus de détection et de connexion pour indiquer qu’une reconnexion automatique est en cours. ## Mettre à jour le logiciel du lecteur [Côté client] - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Votre application doit mettre à jour les lecteurs mobiles pour appliquer les éléments suivants : - des configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - des mises à jour de sécurité L’installation des mises à jour obligatoires se lance lors de la connexion au lecteur. Vous ne pouvez pas utiliser le lecteur tant que la mise à jour n’est pas terminée. > Pour installer des mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque les mises à jour immédiatement nécessaires sont disponibles pour le lecteur, le `MobileReaderListener` de l’intégration reçoit `onStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation de la durée totale de la mise à jour, indiquée par `durationEstimate`. Pendant le processus d’installation, le `connectionStatus` du Terminal passe à `ConnectionStatus.CONNECTING` pendant que la mise à jour s’installe sur le lecteur. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et afficher sa progression dans votre interface utilisateur. Expliquez clairement pourquoi la connexion peut prendre plus de temps que d’habitude. Si le processus de mise à jour requis échoue, Stripe communique l’erreur au `MobileReaderListener` avec `onFinishInstallingUpdate`. Vous ne pouvez pas vous reconnecter au lecteur après l’échec d’une mise à jour requise, sauf si les conditions suivantes sont remplies : - Le lecteur exécute la dernière version du logiciel pour l’emplacement au cours des 30 derniers jours. - La version du SDK Android est supérieure ou égale à la version `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour requise soit incomplète. Lors de la prochaine connexion à ce lecteur, Stripe tente à nouveau d’effectuer la mise à jour requise jusqu’à ce qu’elle soit installée avec succès. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) { // Show UI communicating that a required update has started installing } override fun onReportReaderSoftwareUpdateProgress(progress: Float) { // Update the progress of the installation } override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) { // Report success or failure of the update } // ... } ``` Vous pouvez annuler les mises à jour requises à l’aide de l’objet `Cancelable`, ce qui entraîne également un échec de connexion au lecteur. Vous ne pouvez pas annuler les mises à jour uniquement incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date indiquée, après quoi elles deviennent obligatoires. Le SDK vous informe des mises à jour facultatives via le `MobileReaderListener` chaque fois que le lecteur est connecté mais n’effectue pas de transaction. Si une mise à jour facultative est disponible, le `MobileReaderListener` de votre application reçoit le rappel `onReportAvailableUpdate` avec l’objet `ReaderSoftwareUpdate` contenant les détails de la mise à jour, y compris : - Temps estimé pour la fin de la mise à jour (`durationEstimate`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, signalez aux utilisateurs qu’une mise à jour est disponible et affichez un message les invitant à l’installer. Pour procéder à la mise à jour précédemment signalée avec `onReportAvailableUpdate`, appelez `Terminal.getInstance().installAvailableUpdate`. La mise à jour disponible est également stockée dans l’objet Reader sous la forme `reader.availableUpdate`. Pendant la durée de la mise à jour, empêchez l’utilisateur de quitter la page de votre application et invitez-le à garder le lecteur connecté jusqu’à la fin de la procédure. Nous vous recommandons également d’afficher un indicateur visuel de la progression de la mise à jour. Le `MobileReaderListener` rapporte la progression de la mise à jour dans la méthode `onReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, la mise à jour est installée la prochaine fois que le lecteur est connecté. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) { // An update is available for the connected reader. Show this update in your application. // Install this update using `Terminal.getInstance().installAvailableUpdate`. } // ... } ``` Pour savoir comment vérifier si votre application gère les différents types de mises à jour possibles sur un lecteur, consultez la page [Test des mises à jour d’un lecteur](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates). # Lecteurs USB > This is a Lecteurs USB for when terminal-sdk-platform is react-native and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=usb. > #### Prise en charge des plateformes > > La prise en charge de la connexion aux lecteurs mobiles à l’aide du SDK React Native est actuellement limitée à la plateforme Android. Utilisez le SDK beta.13 React Native (ou version ultérieure) du Terminal Stripe afin de prendre en charge les connexions USB pour les lecteurs [Reader M2 de Stripe](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) et [BBPOS WisePad 3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md). Vous devez utiliser un câble USB qui prend en charge à la fois le transfert de données et la charge, comme le câble USB 2.0 qui est inclus avec le lecteur Stripe M2 et le BBPOS WisePad 3. Si le câble fourni avec votre lecteur de terminal ne permet que la charge, utilisez un câble USB 2.0 tiers qui peut transférer des données. Pour connecter votre application à un lecteur Terminal à l’aide du câble USB : 1. [Détection de lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers). 1. [Connexion à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader). ## Détecter les lecteurs [Côté client] - [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverreaders-1) - [DiscoveryReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/DiscoverReadersParams.html) Assurez-vous que le lecteur est sous tension et connecté avec un câble USB 2.0 à l’appareil exécutant votre application, et que l’accès au lecteur connecté en USB a été autorisé. Si vous branchez le lecteur pour la première fois, une invite du système Android s’affiche pour vous demander de vous connecter au lecteur. Vous pouvez cocher la case « Toujours ouvert » pour ouvrir votre application sans demande lorsqu’elle est connectée à un lecteur. Puis, à partir de votre application, recherchez le lecteur connecté avec la méthode `discoverReaders`, à l’aide de `usb` comme `DiscoveryMethod` . ```js function DiscoverReadersScreen() { const { discoverReaders, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: (readers) => { // After the SDK discovers a reader, your app can connect to it. }, }); useEffect(() => { handleDiscoverReaders(); }, []); const handleDiscoverReaders = async () => { // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method // within the `useStripeTerminal` hook. const { error } = await discoverReaders({ discoveryMethod: 'usb', }); if (error) { Alert.alert( 'Discover readers error: ', `${error.code}, ${error.message}` ); } }; return ; } ``` ## Se connecter à un lecteur [Côté client] - [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) - [ConnectUsbReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/ConnectUsbReaderParams.html) Pour vous connecter à un lecteur détecté, appelez la méthode `connectReader` depuis votre application. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, transmettez le `locationId` approprié à `ConnectUsbReaderParams` lors de la connexion. ```js const handleConnectUsbReader = async (id) => { const { reader, error } = await connectReader({ discoveryMethod: 'usb', reader: selectedReader, locationId: {{LOCATION_ID}}, }); if (error) { console.log('connectReader error', error); return; } console.log('Reader connected successfully', reader); }; ``` > #### Utiliser le mode veille > > Ne programmez pas votre application pour appeler `disconnectReader` afin d’économiser de l’énergie. Le lecteur assure une gestion efficace de l’alimentation à l’aide de son mode veille. ## Gérer les déconnexions des lecteurs - [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT) - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) - [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason) Des déconnexions du lecteur peuvent parfois se produire entre votre application et le lecteur. Par exemple, le lecteur peut se déconnecter de votre application si le câble USB qui le relie à votre appareil est déconnectéil est hors de portée ou sa batterie est déchargée. Vous pouvez simuler une déconnexion inattendue pendant le test en éteignant le lecteur. `UserCallbacks` comprend un `onDidDisconnect` qui fournit à votre application le `DisconnectReason` qui permet d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour traiter vous-même les déconnexions du lecteur, vous pouvez procéder comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur `false` pendant la connexion. 1. Traitez le rappel de déconnexion pour afficher dans l’application un message avertissant l’utilisateur que le lecteur s’est déconnecté de manière inattendue et lancer la détection et la connexion du lecteur. ```js const terminal = useStripeTerminal({ onDidDisconnect: (result) => { // Consider displaying a UI to notify the user and start rediscovering readers }, }); ``` ### Redémarrer le lecteur connecté - [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader) Les lecteurs M2 et BBPOS WisePad 3 de Stripe redémarrent automatiquement après 24 heures de fonctionnement. Vous pouvez cependant forcer le lecteur à redémarrer et réinitialiser sa minuterie de 24 heures à l’aide de l’API `rebootReader`. Après cette action, le lecteur se déconnecte du SDK, puis redémarre. Si vous utilisez la reconnexion automatique, le SDK tente de rétablir la connexion avec le lecteur. ```js const { error } = await rebootReader(); if (error) { console.log('rebootReader error:', error); return; } console.log('rebootReader succeeded'); ``` #### Tentative de reconnexion automatique Lorsqu’un lecteur se déconnecte, nous tentons automatiquement une reconnexion par défaut et vous recommandons d’afficher dans votre application des notifications qui indiquent l’état du lecteur tout au long du processus. Pour afficher des notifications dans votre application lors de la reconnexion automatique, procédez comme suit : 1. Réglez `autoReconnectOnUnexpectedDisconnect` sur true dans `ConnectUsbReaderParams`. 1. Mettez en œuvre les rappels de reconnexion automatique qui se trouvent dans les `UserCallbacks`. 1. Lorsque le SDK envoie `onDidStartReaderReconnect` à votre application, affichez un message indiquant que le lecteur a perdu la connexion et que la reconnexion est en cours. - Vous pouvez utiliser `cancelReaderReconnection` pour interrompre la tentative de reconnexion à tout moment. 1. Lorsque le SDK indique que la reconnexion a réussi en envoyant `onDidSucceedReaderReconnect`, affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si le SDK ne peut pas se reconnecter au lecteur et envoie `onDidFailReaderReconnect`, affichez un message indiquant qu’une déconnexion inattendue s’est produite. #### Reconnexion automatique au démarrage de l’application Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native). 1. Au lancement de votre application, recherchez un numéro de série enregistré dans l’emplacement de stockage persistant des données. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Affichez une interface utilisateur pendant le processus de détection et de connexion pour indiquer qu’une reconnexion automatique est en cours. ## Mettre à jour le logiciel du lecteur [Côté client] - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Votre application doit mettre à jour les lecteurs mobiles pour appliquer les éléments suivants : - des configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - des mises à jour de sécurité L’installation des mises à jour obligatoires se lance lors de la connexion au lecteur. Vous ne pouvez pas utiliser le lecteur tant que la mise à jour n’est pas terminée. > Pour installer des mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque les mises à jour immédiatement nécessaires sont disponibles pour le lecteur, l’intégration reçoit `onDidStartInstallingUpdate` du hook `useStripeTerminal` avec un `Reader.SoftwareUpdate`. Le `Reader.SoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation de la durée totale de la mise à jour, indiquée par `estimatedUpdateTime`. Pendant le processus d’installation, le `connectionStatus` du Terminal passe à `"connecting"` pendant que la mise à jour s’installe sur le lecteur. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et afficher sa progression dans votre interface utilisateur. Expliquez clairement pourquoi la connexion peut prendre plus de temps que d’habitude. Si le processus de mise à jour requis échoue, Stripe communique l’erreur au hook `useStripeTerminal` avec `onDidFinishInstallingUpdate`. Vous ne pouvez pas vous reconnecter au lecteur après l’échec d’une mise à jour requise, sauf si les conditions suivantes sont remplies : - Le lecteur exécute la dernière version du logiciel pour l’emplacement au cours des 30 derniers jours. - La version du SDK React Native est supérieure ou égale à la version `0.0.1-beta.18`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour requise soit incomplète. Lors de la prochaine connexion à ce lecteur, Stripe tente à nouveau d’effectuer la mise à jour requise jusqu’à ce qu’elle soit installée avec succès. ```js const terminal = useStripeTerminal({ onDidReportReaderSoftwareUpdateProgress: (progress) => { setCurrentProgress((Number(progress) * 100).toFixed(0).toString()); }, onDidFinishInstallingUpdate: ({ error }) => { }, onDidStartInstallingUpdate: (update) => { }, }); ``` Vous pouvez annuler les mises à jour requises à l’aide de l’API `cancelInstallingUpdate`, ce qui entraîne également un échec de la connexion au lecteur. Vous ne pouvez pas annuler les mises à jour uniquement incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date indiquée, après quoi elles deviennent obligatoires. Le SDK vous informe des mises à jour facultatives avec le rappel `onDidReportAvailableUpdate` du hook `useStripeTerminal` chaque fois que le lecteur est connecté mais n’effectue pas de transaction. Si une mise à jour facultative est disponible, le hook `useStripeTerminal` de votre application reçoit le rappel `onDidReportAvailableUpdate` avec l’objet `SoftwareUpdate` contenant les détails de la mise à jour, notamment les informations suivantes : - Temps estimé pour l’exécution de la mise à jour (`estimatedUpdateTime`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, signalez aux utilisateurs qu’une mise à jour est disponible et affichez un message les invitant à l’installer. Pour procéder à la mise à jour précédemment signalée avec `onDidReportAvailableUpdate`, appelez `installAvailableUpdate`à partir du hook `useStripeTerminal`. La mise à jour disponible est également stockée dans l’objet Reader sous la forme `reader.availableUpdate`. Pendant la durée de la mise à jour, empêchez l’utilisateur de quitter la page de votre application et invitez-le à garder le lecteur sous la main et sous tension jusqu’au terme de l’installation. Nous vous recommandons également d’afficher un indicateur visuel de la progression de la mise à jour. Le hook `useStripeTerminal` rapporte la progression de la mise à jour dans la méthode `onDidReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, la mise à jour est installée la prochaine fois que le lecteur est connecté. ```js const terminal = useStripeTerminal({ onDidReportAvailableUpdate: (update) => { // An update is available for the connected reader. Show this update in your application. // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook. }, }); ``` Pour savoir comment vérifier si votre application gère les différents types de mises à jour possibles sur un lecteur, consultez la page [Test des mises à jour d’un lecteur](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates). # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is server-driven and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte Stripe. #### Dashboard Vous pouvez enregistrer votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour finaliser l’enregistrement de votre lecteur. Vous pouvez uniquement enregistrer les lecteurs que vous ou votre plateforme avez commandés. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` Une fois votre lecteur enregistré, il est prêt à être utilisé avec l’intégration pilotée par serveur. Nous vous recommandons d’enregistrer l’ID du lecteur (`tmr_xxx`) dans votre application afin de savoir à quel lecteur envoyer les transactions depuis votre point de vente. Vous pouvez récupérer les ID de lecteurs à l’aide de l’endpoint [liste des lecteurs](https://docs.stripe.com/api/terminal/readers/list.md). # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is js and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=internet. > #### 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. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [discoverReaders (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente avec `discoverReaders` en définissant`discoveryMethod` sur `internet`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. ```javascript async function discoverReaders() { const config = {simulated: false, location: "{{LOCATION_ID}}"} const discoverResult = await terminal.discoverReaders(config); if (discoverResult.error) { console.log('Failed to discover: ', discoverResult.error); } else if (discoverResult.discoveredReaders.length === 0) { console.log('No available readers.'); } else { // You should show the list of discoveredReaders to the // cashier here and let them select which to connect to (see below). connectReader(discoverResult); } } ``` ## Se connecter à un lecteur [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). Pour connecter votre application de point de vente à un lecteur, appelez le [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) avec le lecteur sélectionné. ```javascript async function connectReader(discoverResult) { // Just select the first reader here. const selectedReader = discoverResult.discoveredReaders[0]; const connectResult = await terminal.connectReader(selectedReader); if (connectResult.error) { console.log('Failed to connect:', connectResult.error); } else { console.log('Connected to reader:', connectResult.reader.label); } } ``` - [connectReader (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode '`connectReader` utilise un objet de configuration avec une propriété `fail_if_in_use` dont la valeur par défaut est `false`. Lorsque votre application définit `fail_if_in_use` sur « true », l’appel `connectReader` présente un autre comportement : la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `processPayment` lancé par un autre SDK. Si le lecteur est connecté à un autre SDK mais qu’il est inactif (s’il affiche l’écran d’accueil avant l’appel de `collectPaymentMethod`), le paramétrage de `fail_if_in_use` ne modifie pas le comportement de la connexion, et la demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. ```javascript const connectResult = await terminal.connectReader(reader, {fail_if_in_use: true}); ``` | | fail_if_in_use est « false » (par défaut) | fail_if_in_use est « true » | | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `fail_if_in_use` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `fail_if_in_use` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [StripeTerminal.create (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-create) Votre application doit implémenter le rappel `onUnexpectedReaderDisconnect` afin de remédier à toute déconnexion du lecteur. Lors de la mise en place de ce rappel, affichez une interface utilisateur qui informe l’utilisateur de la déconnexion du lecteur. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et initier une reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. ```javascript const terminal = StripeTerminal.create({ onFetchConnectionToken: fetchConnectionToken, onUnexpectedReaderDisconnect: unexpectedDisconnect, }); function unexpectedDisconnect() { // Consider displaying a UI to notify the user and start rediscovering readers } ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage). 1. Au lancement de votre application, vérifiez si un numéro de série enregistré se trouve dans cet emplacement persistant. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is ios and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) - [InternetDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetDiscoveryConfiguration.html) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente avec `discoverReaders` en utilisant `InternetDiscoveryConfiguration`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. #### Swift ```swift import StripeTerminal class DiscoverReadersViewController: UIViewController, DiscoveryDelegate { func discoverReadersAction() throws { let config = try InternetDiscoveryConfigurationBuilder() .setLocationId(""{{LOCATION_ID}}"") .build() // In addition to Terminal's completion block methods, Swift async alternatives are available. // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in if let error = error { print("discoverReaders failed: \(error)") } else { print("discoverReaders succeeded") } } } } ``` Lors de la découverte de lecteurs intelligents, la méthode `DiscoveryDelegate.didUpdateDiscoveredReaders` n’est sollicitée qu’une fois par appel à `discoverReaders`. `didUpdateDiscoveredReaders` renvoie une liste vide de lecteurs lorsqu’aucun lecteur n’est enregistré ou qu’aucun lecteur n’est associé à l’emplacement donné. Si vous sollicitez ultérieurement `discoverReaders` pour rafraîchir la liste, vous devez au préalable annuler l’appel précédent avec le `Cancelable` retourné par `discoverReaders`. `InternetDiscoveryConfiguration` prend en charge une valeur facultative `timeout` pour la détection des lecteurs en ligne. Cela permet d’accélérer la détection des lecteurs hors ligne en cas d’échec de la tentative en ligne. ## Se connecter à un lecteur [Côté client] > Dans la version `5.1.0` du SDK iOS, vous pouvez utiliser la méthode `easyConnect` pour combiner la détection du lecteur et la connexion en un seul appel API. Pour plus d’informations, consultez le [guide de migration](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) du SDK. Pour connecter votre application de point de vente à un lecteur, appelez `connectReader` avec le lecteur sélectionné en utilisant la fonction `InternetConnectionConfiguration`. #### Swift ```swift let config: InternetConnectionConfiguration do { config = try InternetConnectionConfigurationBuilder(delegate: yourInternetReaderDelegate) .build() } catch { // Handle error building the connection configuration return } Terminal.shared.connectReader(selectedReader, connectionConfig: config) { reader, error in if let reader = reader { print("Successfully connected to reader: \(reader)") } else if let error = error { print("connectReader failed: \(error)") } } ``` - [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:) - [InternetConnectionConfiguration](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetConnectionConfiguration.html) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode `connectReader` utilise un objet Configuration avec une propriété `failIfInUse` dont la valeur par défaut est `false`. Lorsque votre application définit `failIfInUse` sur true, l’appel `connectReader` a un comportement alternatif où la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par un SDK. Si le lecteur est connecté à un SDK mais qu’il est inactif (il affiche l’écran d’accueil avant l’appel de `collectPaymentMethod`), le paramétrage de `failIfInUse` ne modifie pas le comportement de la connexion. La demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. #### Swift ```swift let internetReaderDelegate = yourInternetReaderDelegate // implement your internetReaderDelegate let config: InternetConnectionConfiguration do { config = try InternetConnectionConfigurationBuilder(delegate: internetReaderDelegate) .setFailIfInUse(true) .build() } catch { // Handle error building the connection configuration return } Terminal.shared.connectReader(selectedReader, connectionConfig: config, completion: { reader, error in // ... }) ``` | | failIfInUse est « false » (par défaut) | failIfInUse est « true » | | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `didDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `didDisconnect` de cette application est appelée. | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `didDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `failIfInUse` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `failIfInUse` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [didDisconnect (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:) Votre application doit mettre en place le rappel `reader(_, didDisconnect:)` afin de remédier à toute déconnexion du lecteur. Lors de la mise en place de ce rappel, affichez une interface utilisateur qui informe l’utilisateur du que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et initier une reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. #### Swift ```swift import StripeTerminal class ReaderViewController: UIViewController, InternetReaderDelegate { override func viewDidLoad() { super.viewDidLoad() // Set the reader delegate when connecting to a reader } // ... func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } } ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults) (iOS). 1. Au lancement de votre application, vérifiez si un numéro de série enregistré se trouve dans cet emplacement persistant. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is android and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) - [InternetDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente avec `discoverReaders` en utilisant `InternetDiscoveryConfiguration`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. #### Kotlin ```kotlin var discoveryCancelable: Cancelable? = null fun onDiscoverReaders() { val timeout = 0 val isSimulated = false val config = InternetDiscoveryConfiguration( timeout = timeout, isSimulated = isSimulated, location = ""{{LOCATION_ID}}"" ) // Save this cancelable to an instance variable discoveryCancelable = Terminal.getInstance().discoverReaders( config, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { // Display the discovered readers to the user } }, object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } override fun onStop() { super.onStop() // If you're leaving the activity or fragment without selecting a reader, // make sure you cancel the discovery process or the SDK will be stuck in // a discover readers phase. discoveryCancelable?.cancel( object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } ``` ## Se connecter à un lecteur [Côté client] > Dans la version `5.0.0` du SDK Android, vous pouvez utiliser la méthode `easyConnect` pour combiner la détection du lecteur et la connexion en un seul appel à l’API pour une expérience d’intégration plus simple. Pour en savoir plus, consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage). Pour connecter votre application de point de vente à un lecteur, appelez `connectReader` avec le lecteur sélectionné en utilisant la fonction `InternetConnectionConfiguration`. #### Kotlin ```kotlin val internetReaderListener = yourInternetReaderListener val config = InternetConnectionConfiguration(internetReaderListener) Terminal.getInstance().connectReader( firstReader, config, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` - [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) - [InternetConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode `connectReader` utilise un objet Configuration avec une propriété `failIfInUse` dont la valeur par défaut est `false`. Lorsque votre application définit `failIfInUse` sur true, l’appel `connectReader` a un comportement alternatif où la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par un SDK. Si le lecteur est connecté à un SDK mais qu’il est inactif (il affiche l’écran d’accueil avant l’appel de `collectPaymentMethod`), le paramétrage de `failIfInUse` ne modifie pas le comportement de la connexion. La demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. #### Kotlin ```kotlin val failIfInUse = true val internetReaderListener = yourInternetReaderListener val config = InternetConnectionConfiguration(internetReaderListener, failIfInUse) Terminal.getInstance().connectReader( reader, config, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` | | failIfInUse est « false » (par défaut) | failIfInUse est « true » | | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `failIfInUse` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `failIfInUse` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [onDisconnect (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html) Votre application doit mettre en place le rappel `onDisconnect` afin de remédier à toute déconnexion du lecteur. Lors de la mise en place de ce rappel, affichez une interface utilisateur qui informe l’utilisateur du que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et initier une reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), InternetReaderListener { // ... override fun onDisconnect(reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } // ... } ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android). 1. Au lancement de votre application, vérifiez si un numéro de série enregistré se trouve dans cet emplacement persistant. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is react-native and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente avec `discoverReaders` en définissant`discoveryMethod` sur `internet`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. ```js export default function DiscoverScreen() { const { discoverReaders, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: (readers) => { // After the SDK discovers a reader, your app can connect to it. }, }); useEffect(() => { const fetchReaders = async () => { const { error } = await discoverReaders({ discoveryMethod: 'internet', }); } fetchReaders(); }, [discoverReaders]); return ; } ``` ## Se connecter à un lecteur [Côté client] > Dans la version `0.0.1-bêta.29` du SDK React Native, vous pouvez utiliser la méthode [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) pour combiner la découverte du lecteur et la connexion en un seul appel d’API, afin de simplifier l’expérience d’intégration. Pour connecter votre application de point de vente à un lecteur, appelez le `connectReader` avec le lecteur sélectionné. ```js const { reader, error } = await connectReader({ discoveryMethod: 'internet', reader, }); if (error) { console.log('connectReader error:', error); return; } console.log('Reader connected successfully', reader); ``` - [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode `connectReader` utilise un objet Configuration avec une propriété `failIfInUse` dont la valeur par défaut est `false`. Lorsque votre application définit `failIfInUse` sur true, l’appel `connectReader` a un comportement alternatif où la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par un SDK. Si le lecteur est connecté à un SDK mais qu’il est inactif (il affiche l’écran d’accueil avant l’appel de `collectPaymentMethod`), le paramétrage de `failIfInUse` ne modifie pas le comportement de la connexion. La demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. ```js const { reader: connectedReader, error } = await connectReader({ discoveryMethod: 'internet', reader, failIfInUse: true, }); ``` | | failIfInUse est « false » (par défaut) | failIfInUse est « true » | | ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectInternetReader` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDidDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDidDisconnect` de cette application est appelée. | | `connectInternetReader` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDidDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `failIfInUse` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `failIfInUse` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Votre application doit implémenter le rappel `onDidDisconnect` pour gérer la déconnexion d’un lecteur. Lorsque vous implémentez ce rappel, affichez une interface utilisateur qui notifie votre utilisateur du lecteur déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et initier la reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. ```js const terminal = useStripeTerminal({ onDidDisconnect: (result) => { // Consider displaying a UI to notify the user and start rediscovering readers }, }); ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is java and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=java&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [discoverReaders (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/discover-readers.html) - [InternetDiscoveryConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente avec `discoverReaders` en utilisant `InternetDiscoveryConfiguration`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. ```java private Cancelable discoveryCancelable; public void onDiscoverReaders() { int timeout = 0; boolean isSimulated = false; InternetDiscoveryConfiguration config = new InternetDiscoveryConfiguration( timeout, ""{{LOCATION_ID}}"", isSimulated, DiscoveryFilter.None.INSTANCE ); // Save this cancelable to an instance variable discoveryCancelable = Terminal.getInstance().discoverReaders( config, readers -> { // Display the discovered readers to the user }, new Callback() { @Override public void onSuccess() { // Placeholder for handling successful operation } @Override public void onFailure(@NotNull TerminalException e) { // Placeholder for handling exception } } ); } ``` ## Se connecter à un lecteur [Côté client] > Dans la version `1.0.0-b15` du SDK Java, vous pouvez utiliser la méthode [easyConnect](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/easy-connect.html) pour combiner la découverte du lecteur et la connexion en un seul appel API, simplifiant ainsi l’intégration. Pour connecter votre application de point de vente à un lecteur, appelez `connectReader` avec le lecteur sélectionné en utilisant la fonction `InternetConnectionConfiguration`. ```java InternetReaderListener internetReaderListener = yourInternetReaderListener; InternetConnectionConfiguration config = new InternetConnectionConfiguration(internetReaderListener); Terminal.getInstance().connectReader( reader, config, new ReaderCallback() { @Override public void onSuccess(@NotNull Reader reader) { // Placeholder for handling successful operation } @Override public void onFailure(@NotNull TerminalException e) { // Placeholder for handling exception } } ); ``` - [connectReader (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/connect-reader.html) - [InternetConnectionConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode `connectReader` utilise un objet Configuration avec une propriété `failIfInUse` dont la valeur par défaut est `false`. Lorsque votre application définit `failIfInUse` sur true, l’appel `connectReader` a un comportement alternatif où la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par un SDK. Si le lecteur est connecté à un SDK mais qu’il est inactif (il affiche l’écran d’accueil avant l’appel de `collectPaymentMethod`), le paramétrage de `failIfInUse` ne modifie pas le comportement de la connexion. La demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. ```java boolean failIfInUse = true; InternetReaderListener internetReaderListener = yourInternetReaderListener; InternetConnectionConfiguration config = new InternetConnectionConfiguration(internetReaderListener, failIfInUse); Terminal.getInstance().connectReader( reader, config, new ReaderCallback() { @Override public void onSuccess(@NotNull Reader reader) { // Placeholder for handling successful operation } @Override public void onFailure(@NotNull TerminalException e) { // Placeholder for handling exception } } ); ``` | | failIfInUse est « false » (par défaut) | failIfInUse est « true » | | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | | `connectReader` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `onDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `failIfInUse` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `failIfInUse` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [onDisconnect (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html) Votre application doit mettre en place le rappel `onDisconnect` afin de remédier à toute déconnexion du lecteur. Lors de la mise en place de ce rappel, affichez une interface utilisateur qui informe l’utilisateur du que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et initier une reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. ```java public class CustomReaderListener implements InternetReaderListener { // ... @Override public void onDisconnect(@NotNull DisconnectReason reason) { // Consider displaying a UI to notify the user and start rediscovering readers } // ... } ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. 1. Lorsque vous vous connectez à un lecteur, enregistrez son numéro de série dans un emplacement de stockage persistant, comme l’[API Preferences](https://docs.oracle.com/javase/8/docs/api/java/util/prefs/Preferences.html). 1. Au lancement de votre application, vérifiez si un numéro de série enregistré se trouve dans cet emplacement persistant. Si vous en trouvez un, appelez la méthode `discoverReaders` afin que votre application puisse essayer de retrouver le lecteur. 1. Si le numéro de série enregistré correspond à l’un des lecteurs détectés, essayez de vous connecter à ce lecteur à l’aide de l’objet Reader correspondant renvoyé par l’appel à `discoverReaders`. Si le lecteur en question est introuvable, mettez fin au processus de recherche. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Lecteurs internet > This is a Lecteurs internet for when terminal-sdk-platform is dotnet and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=dotnet&reader-type=internet. Les lecteurs intelligents exécutent le logiciel du lecteur Stripe pour communiquer directement avec Stripe via Internet. Pour connecter votre application à un lecteur intelligent, suivez ces trois étapes : 1. [Enregistrer un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) sur votre compte Stripe. 1. [Détecter des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) avec le SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec le SDK ## Enregistrer un lecteur [Côté serveur] Avant de pouvoir connecter votre application à un lecteur intelligent, vous devez enregistrer le lecteur sur votre compte. #### Dashboard ### Enregistrement dans le Dashboard Vous pouvez ajouter votre lecteur directement dans le [Dashboard](https://dashboard.stripe.com/test/terminal). #### Enregistrer par code d’enregistrement 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement et cliquez sur **Suivant**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par numéro de série 1. Sur la page [Lecteurs](https://dashboard.stripe.com/terminal/readers), cliquez sur **Enregistrer un lecteur**. 1. Recherchez le numéro de série de l’appareil et saisissez-le. Pour enregistrer plusieurs appareils à la fois, vous pouvez saisir plusieurs numéros de série séparés par des virgules. 1. Vous pouvez facultativement choisir un nom pour le lecteur. 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Sur la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), trouvez une commande dont le statut est « expédié » ou « livré ». Cliquez sur le menu de débordement (⋯) à la fin de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer des lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Vous pouvez facultativement choisir un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs de manière séquentielle (par exemple, pour une entrée donnée « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », et ainsi de suite). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez-en un en cliquant sur **+ Ajouter un emplacement**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### API Dans le cadre de déploiements de plus grande envergure, donnez à vos utilisateurs sur le terrain la possibilité de recevoir et de configurer eux-mêmes de nouveaux lecteurs. Dans votre application, créez un flux permettant d’[enregistrer](https://docs.stripe.com/api/terminal/readers/create.md) un lecteur à l’aide de l’API Stripe. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence `0-7-1-3-9` pour afficher un code d’inscription unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou Stripe Reader S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings), puis appuyez sur **Générer un code d’association**. 1. L’utilisateur saisit le code dans votre application. 1. Votre application envoie le code à Stripe : ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` Afin de confirmer le bon enregistrement de votre lecteur, listez tous les lecteurs que vous avez enregistrés à cet emplacement : #### curl ```bash curl https://api.stripe.com/v1/terminal/readers \ -u <>: ``` ## Détecter les lecteurs [Côté client] - [DiscoverReadersAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME) Après avoir enregistré le lecteur sur votre compte, recherchez les lecteurs précédemment enregistrés afin de vous connecter à votre application de point de vente à l’aide de la méthode `DiscoverReadersAsync`. Vous pouvez affiner votre recherche en spécifiant l’emplacement `location` dans lequel vous avez enregistré le lecteur lors de l’étape précédente. ```csharp public async Task> DiscoverReadersAsync() { try { var config = new DiscoveryConfiguration.Builder() .SetIsSimulated(false) .SetLocation("{{LOCATION_ID}}") .Build(); Console.WriteLine("Discovered readers"); return await Terminal.Instance.DiscoverReadersAsync(config); } catch (TerminalException ex) { // Placeholder for handling exception throw; } } ``` ## Se connecter à un lecteur [Côté client] Pour connecter votre application de point de vente à un lecteur, appelez `ConnectInternetReaderAsync` avec le lecteur sélectionné. ```csharp // after selecting a reader to connect to Reader connectedReader; try { var config = new InternetConnectionConfiguration.Builder() .Build(); connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config); Console.WriteLine("Connected to reader"); } catch (TerminalException ex) { // Placeholder for handling exception throw; } ``` - [ConnectInternetReaderAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME) ### Connexions multiples Une seule instance du SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `ConnectInternetReaderAsync` à partir d’une autre application, la connexion entrante remplace la connexion existante entre le SDK et le lecteur, et le SDK précédemment connecté se déconnecte du lecteur. La méthode '`ConnectInternetReaderAsync` utilise un objet de configuration avec une propriété `failIfInUse` dont la valeur par défaut est `false`. Lorsque votre application définit `failIfInUse` sur « true », l’appel `ConnectInternetReaderAsync` présente un autre comportement : la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `CollectPaymentMethodAsync` ou `ConfirmPaymentIntentAsymc` lancé par un autre SDK. Si le lecteur est connecté à un autre SDK mais qu’il est inactif (s’il affiche l’écran d’accueil avant l’appel de `CollectPaymentMethodAsync`), le paramétrage de `failIfInUse` ne modifie pas le comportement de la connexion, et la demande de connexion entrante peut toujours interrompre la connexion SDK-lecteur existante. ```csharp // after selecting a reader to connect to Reader connectedReader; try { var config = new InternetConnectionConfiguration.Builder() .SetFailIfInUse(true) .Build(); connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config); Console.WriteLine("Connected to reader"); } catch (TerminalException ex) { // Placeholder for handling exception throw; } ``` | | FailIfInUse est « false » (par défaut) | FailIfInUse est « true » | | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `ConnectInternetReaderAsync` appelé depuis un nouveau SDK lorsque le lecteur est inactif. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `OnUnexpectedReaderDisconnect` de cette application est appelée. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `OnUnexpectedReaderDisconnect` de cette application est appelée. | | `ConnectInternetReaderAsync` appelé depuis un nouveau SDK lorsque le lecteur est en train d’effectuer une transaction. | La connexion SDK-lecteur existante est interrompue, et le nouveau SDK se connecte au lecteur. La commande suivante du SDK précédemment connecté échoue avec une erreur de lecteur, et la méthode `OnUnexpectedReaderDisconnect` de cette application est appelée. | La connecter entrante échoue avec une erreur de lecteur. La connecter SDK-lecteur existante n’est pas interrompue et la commande en cours se poursuit. | Pour perturber le moins possible l’expérience de connexion dans les environnements à plusieurs lecteurs, nous vous recommandons de définir la valeur `failIfInUse` sur `true` lors de la première tentative de connexion de votre application. Ensuite, permettez à vos utilisateurs de réessayer la connexion avec `failIfInUse` sur `false` si la connexion échoue la première fois. Avec cette configuration, vos utilisateurs ne peuvent pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peuvent toujours se connecter si nécessaire. ### Gérer les déconnexions - [TerminalListener (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME) Votre application doit implémenter le rappel `OnUnexpectedReaderDisconnect` afin de remédier à toute déconnexion du lecteur. Lors de la mise en place de ce rappel, affichez une interface utilisateur qui informe l’utilisateur de la déconnexion du lecteur. Vous pouvez appeler `DiscoverReadersAsync` pour rechercher des lecteurs et initier une reconnexion. Votre application peut tenter de se reconnecter automatiquement au lecteur déconnecté ou afficher une interface utilisateur qui invite l’utilisateur à se reconnecter à un autre lecteur. Le lecteur peut se déconnecter de votre application s’il perd la connexion au réseau. Pour simuler une déconnexion inattendue, éteignez le lecteur. ```csharp public class TerminalListener : ITerminalListener { // ... Terminal.InitTerminal( connectionTokenProvider: connectionTokenProvider, terminalListener: this, offlineListener: offlineListener, applicationInformation: applicationInformation ); // ITerminalListener public void OnUnexpectedReaderDisconnect(Reader reader) { // Consider displaying a UI to notify the user and start rediscovering readers } } ``` ### Reconnexion automatique Stripe Terminal ne se reconnecte pas automatiquement à un lecteur au démarrage de votre application. Vous pouvez créer un flux de reconnexion en enregistrant les ID de lecteur et en essayant de vous connecter à un lecteur connu au démarrage. Au cours du processus de détection et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Tap to Pay sur iPhone > This is a Tap to Pay sur iPhone for when terminal-sdk-platform is ios and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=tap-to-pay. Tap to Pay sur iPhone permet aux utilisateurs d’accepter des paiements par TPE sans contact avec un [iPhone compatible](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) et le [Terminal Stripe SDK](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios). Tap to Pay sur iPhone prend en charge les cartes sans contact Visa, Mastercard, American Express et Discover, ainsi que les portefeuilles mobiles NFC (Apple Pay, Google Pay et Samsung Pay). Tap to Pay sur iPhone est inclus dans le SDK Terminal iOS et permet de payer directement dans votre application mobile iOS. ## Détecter les lecteurs - [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) - [TapToPayDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Reader%20Discovery%20%26%20Connection.html#/c:objc\(cs\)SCPTapToPayDiscoveryConfiguration) Utilisez la méthode [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) pour déterminer si votre iPhone est compatible avec Tap to Pay. Le gestionnaire `completion` est appelé avec une erreur si votre application s’exécute sur un appareil qui ne répond pas aux [critères de prise en charge de l’appareil](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices). #### Swift ```swift import StripeTerminal class DiscoverReadersViewController: UIViewController, DiscoveryDelegate { var discoverCancelable: Cancelable? // ... // Action for a "Discover Readers" button func discoverReadersAction() throws { let config = try TapToPayDiscoveryConfigurationBuilder().build() // In addition to Terminal's completion block methods, Swift async alternatives are available. // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in if let error = error { print("discoverReaders failed: \(error)") } else { print("discoverReaders succeeded") } } } // ... // MARK: DiscoveryDelegate func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) { // In your app, display the ability to use your phone as a reader // Call `connectReader` to initiate a session with the phone } } ``` ## Se connecter à un lecteur > Dans la version `5.1.0` du SDK iOS, vous pouvez utiliser la méthode `easyConnect` pour combiner la détection du lecteur et la connexion en un seul appel API. Pour plus d’informations, consultez le [guide de migration](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) du SDK. - [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:) - [TapToPayConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTapToPayConnectionConfiguration.html) Pour commencer à accepter les paiements Tap to Pay sur iPhone, fournissez le lecteur détecté à la méthode `connectReader`. Vous devrez également [créer un délégué](https://docs.stripe.com/terminal/payments/connect-reader.md#device-setup) pour gérer les mises à jour potentielles requises pour le lecteur. À la connexion, vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md). Pour ce faire, créez et utilisez une `SCPTapToPayConnectionConfiguration` avec le `locationId` réglé sur l’ID de l’emplacement à associer lors de la connexion. Définissez l’attribut `display_name` pour qu’il représente le nom de l’entreprise lors de la création d’un emplacement. Votre client voit s’afficher le `display_name` de l’emplacement sur l’écran tactile de l’appareil, à moins que vous ne fournissiez explicitement le nom d’une entreprise lorsque vous vous connectez à un lecteur. Vous pouvez modifier les emplacements existants si nécessaire pour ajuster ce texte. Si vous utilisez des [paiements indirects avec on_behalf_of](https://docs.stripe.com/terminal/features/connect.md#destination-payment-intents), vous devez également fournir l’ID du compte connecté dans `SCPTapToPayConnectionConfiguration`. #### Swift ```swift // Call `connectReader` with the selected reader and a connection config // to register to a location as set by your app. let connectionConfig = try TapToPayConnectionConfigurationBuilder.init(locationId: ""{{LOCATION_ID}}"") .delegate(yourTapToPayReaderDelegate) .build() Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in if let reader = reader { print("Successfully connected to reader: \(reader)") } else if let error = error { print("connectReader failed: \(error)") } } ``` ### Gérer la configuration des appareils Lors d’une connexion à un lecteur Tap to Pay sur iPhone compatible, une mise à jour de la configuration peut être requise et prendre quelques minutes. Il est recommandé d’opérer la connexion au lecteur à l’avance en arrière-plan afin de réduire le temps d’attente pour les entreprises. Assurez-vous que votre application implémente `SCPTapToPayReaderDelegate` afin de gérer les étapes de configuration et d’afficher un message à l’intention de votre entreprise pour qu’elle reste en attente. Les étapes de configuration sont comparables à un processus de mise à jour logicielle, et vous pouvez afficher la progression à vos entreprises, le cas échéant. #### Swift ```swift class APPReaderViewController: TapToPayReaderDelegate { // MARK: TapToPayReaderDelegate // ... func tapToPayReader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) { // In your app, let the user know that an update is being installed on the reader } func tapToPayReader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) { // The update or configuration process has reached the specified progress (0.0 to 1.0) // If you are displaying a progress bar or percentage, this can be updated here } func tapToPayReader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) { // The reader has finished installing an update // If `error` is nil, it is safe to proceed and start collecting payments // Otherwise, check the value of `error` for more information on what went wrong } func tapToPayReader(_ reader: Reader, didRequestReaderDisplayMesage displayMessage: ReaderDisplayMessage) { // This is called to request that a prompt be displayed in your app. // Use Terminal.stringFromReaderDisplayMessage(:) to get a user-facing string for the prompt } func tapToPayReader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) { // This is called when the reader begins waiting for input // Use Terminal.stringFromReaderInputOptions(:) to get a user-facing string for the input options } // ... } ``` ### Liens avec les comptes et conditions générales d’Apple Tous les utilisateurs doivent accepter les Conditions générales de Tap to Pay sur iPhone d’Apple avant d’accepter le paiement pour la première fois. Pour les utilisateurs Connect, chaque compte connecté doit accepter les Conditions générales individuellement lorsque : - Un utilisateur Connect crée des paiements directs - Un utilisateur Connect crée un paiement indirect et spécifie un compte `on_behalf_of` Les utilisateurs peuvent accepter les Conditions générales de Tap to Pay sur iPhone d’Apple sur le Web avant de se connecter pour la première fois au lecteur à l’aide de [liens d’inscription](https://docs.stripe.com/api/terminal/onboarding-link.md?api-version=2025-07-30.preview). Les utilisateurs se verront également présenter les Conditions générales de Tap to Pay sur iPhone d’Apple lors de leur première connexion au lecteur dans une application mobile. Pour accepter les Conditions générales d’Apple, l’utilisateur doit fournir un identifiant Apple valide représentant l’entreprise. Une fois que les utilisateurs ont accepté les Conditions générales de Tap to Pay sur iPhone d’Apple, ils ne sont plus invités à se connecter ultérieurement à l’aide du même compte Stripe, y compris sur d’autres appareils mobiles. ![Processus en trois étapes montrant la connexion avec l’Apple ID, l’acceptation des conditions et la confirmation de succès pour Tap to Pay sur iPhone.](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png) Associer votre compte Apple ID pour accepter les paiements Tap to Pay Tout iPhone peut utiliser jusqu’à 3 comptes Stripe uniques dans les applications au cours d’une période de 24 heures lors de l’appel de la méthode `connectReader` pour Tap to Pay sur iPhone. Si des comptes supplémentaires sont utilisés pour l’appareil au cours de la même période de 24 heures, la méthode `connectReader` génère une erreur [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked). Pour en savoir plus sur la liaison de comptes, consultez la section Informations de l’entreprise de la [FAQ d’Apple dédiée à Tap to Pay sur iPhone](https://register.apple.com/tap-to-pay-on-iphone/faq.html). ## Gérer les déconnexions Votre lecteur se déconnecte lorsque votre application passe en arrière-plan ou que votre iPhone perd sa connexion. Il existe deux manières de gérer cela : - [TapToPayReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPTapToPayReaderDelegate.html) #### Gérer la déconnexion manuellement Votre application doit implémenter la méthode de délégation [SCPTapToPayReaderDelegate reader:didDisconnect:](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:) pour gérer cette déconnexion. Ce rappel peut être l’occasion d’informer l’utilisateur qu’un problème est survenu et que vous avez besoin d’une connexion Internet pour continuer. Vous pouvez également vous reconnecter manuellement au lecteur lorsque votre application est à nouveau au premier plan. #### Swift ```swift import StripeTerminal class ReaderViewController: UIViewController, TapToPayReaderDelegate { override func viewDidLoad() { super.viewDidLoad() // Set the reader delegate when connecting to a reader } // ... func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } } ``` #### Tentative de reconnexion automatique Mettez en œuvre les méthodes de reconnexion automatique dans le `SCPTapToPayReaderDelegate`. Vous devez ensuite transmettre le `SCPTapToPayReaderDelegate` à votre `SCPTapToPayConnectionConfiguration`. #### Swift ```swift let connectionConfig = try TapToPayConnectionConfigurationBuilder(locationId: locationId) .delegate(yourTapToPayReaderDelegate) .build() Terminal.shared.connectReader( reader, connectionConfig: connectionConfig, completion: connectCompletion ) ``` Si vous tentez de vous reconnecter automatiquement, les événements suivants se produisent : 1. En cas de déconnexion, le SDK tente automatiquement de se reconnecter et vous informe via `onReaderReconnectStarted`. Assurez-vous que votre application annonce que la connexion a été perdue et qu’une reconnexion est en cours. - Vous pouvez utiliser l’objet `Cancelable` pour arrêter la tentative de reconnexion à tout moment. 1. Si le SDK parvient à se reconnecter au lecteur, Stripe vous envoie une notification `onReaderReconnectSucceeded`. Assurez-vous que votre application signale à l’utilisateur que la connexion a été restaurée et qu’il peut reprendre ses opérations habituelles. 1. Si le SDK ne parvient pas à se reconnecter au lecteur, Stripe vous envoie une notification `onReaderReconnectFailed` et `reader:didDisconnect:`. Assurez-vous que votre application signale à l’utilisateur qu’une déconnexion inattendue s’est produite. #### Swift ```swift import StripeTerminal extension ReaderViewController: TapToPayReaderDelegate { // MARK: ReconnectionDelegate func reader(_ reader: Reader, didStartReaderReconnect cancelable: Cancelable) { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time } func readerDidSucceedReaderReconnect(_ reader: Reader) { // 2. Notified when reader reconnection succeeds // App is now connected } func readerDidFailReaderReconnect(_ reader: Reader) { // 3. Notified when reader reconnection fails // App is now disconnected } } ``` # Tap to Pay sur Android > This is a Tap to Pay sur Android for when terminal-sdk-platform is android and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=tap-to-pay. Tap to Pay sur Android (TTPA) permet aux utilisateurs d’accepter des paiements sans contact en personne avec des [appareils Android compatibles équipés de la technologie NFC](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices). TTPA nécessite la dernière version du [Terminal Android SDK](https://stripe.dev/stripe-terminal-android/). TTPA prend en charge les cartes bancaires sans contact Visa, Mastercard et American Express, ainsi que les wallets mobiles basés sur le NFC (Apple Pay, Google Pay et Samsung Pay). TTPA est une extension du Terminal Android SDK et permet d’effectuer des paiements directement dans votre application Android. Suivez ces étapes pour connecter votre application au lecteur Tap to Pay sur un appareil Android compatible : 1. [Initialisez le SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) pour TTPA. 1. [Détectez des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) à l’aide du SDK pour confirmer la compatibilité des appareils. 1. [Connectez-vous à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) à l’aide du SDK pour accepter des paiements. 1. [Gérez les déconnexions inattendues](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) pour vous assurer que votre utilisateur puisse continuer à accepter des paiements si le lecteur se déconnecte de manière inattendue. Si votre application s’exécute sur un appareil qui ne répond pas aux [critères de prise en charge des appareils](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices), le SDK renvoie une erreur `TerminalException` fournissant davantage d’informations dans un rappel `onFailure`. ## Initialiser le SDK - [TapToPay (Android)](https://stripe.dev/stripe-terminal-android/cots/com.stripe.stripeterminal.taptopay/-tap-to-pay/-companion/is-in-tap-to-pay-process.html) TTPA fonctionne selon un processus dédié pour rendre les transactions plus sûres. Au cours de ce processus, une deuxième instance de votre `Application` est créée. Pour éviter toute erreur inattendue causée par l’exécution de votre code dans ce processus, vous pouvez ignorer l’initialisation de votre `Application` dans ce processus en vérifiant `TapToPay.isInTapToPayProcess()`. ```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() // Skip initialization if running in the TTPA process. if (TapToPay.isInTapToPayProcess()) return // For example, this will be skipped. TerminalApplicationDelegate.onCreate(this) } } ``` ## Détecter les lecteurs - [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) - [TapToPayDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-tap-to-pay-discovery-configuration/index.html) Utilisez la méthode `discoverReaders` pour déterminer si un appareil Android est compatible avec Tap to Pay. `discoverReaders` vérifie les exigences suivantes : - Dispose d’un capteur NFC intégré et fonctionnel et d’un processeur ARM. - Fonctionne sous Android 13 ou version ultérieure - Dispose d’un keystore avec prise en charge matérielle pour ECDH ([`FEATURE_HARDWARE_KEYSTORE`](https://developer.android.com/reference/android/content/pm/PackageManager#FEATURE_HARDWARE_KEYSTORE) version doit être 100 ou ultérieure) - Pour la version réelle du lecteur Tap to Pay, l’application ne peut pas être déboguée. Votre application *doit* êtreau premier plan pour que le service de lecteur Tap to Pay puisse se lancer. Si votre application s’exécute sur un appareil qui ne répond pas aux exigences ci-dessus, le rappel `onFailure` renvoie une erreur `TerminalException` contenant un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) et des informations supplémentaires. À ce stade, les échecs ne sont pas exploitables par l’utilisateur final. Vous ne pouvez pas utiliser la version de production non simulée du lecteur Tap to Pay avec des applications déboguées ou lorsque les options de développement de l’appareil sont activées. Pour tester votre intégration avec Tap to Pay sur Android, définissez la valeur `TapToPayDiscoveryConfiguration.isSimulated` sur `true` lors de la détection du lecteur. Vous devrez définir cette valeur sur `false` dans la version commerciale de votre application. #### Kotlin ```kotlin var discoverCancelable: Cancelable? = null fun onDiscoverReaders() { val isApplicationDebuggable = 0 != applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE val config = TapToPayDiscoveryConfiguration(isSimulated = isApplicationDebuggable) // Save this cancelable to an instance variable discoverCancelable = Terminal.getInstance().discoverReaders( config, object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { // Automatically connect to supported mobile readers } }, object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } override fun onStop() { super.onStop() // If you're leaving the activity or fragment without selecting a reader, // make sure you cancel the discovery process or the SDK will be stuck in // a discover readers phase discoverCancelable?.cancel( object : Callback { override fun onSuccess() { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) } ``` Pour vérifier si un appareil respecte les exigences de Tap to Pay en matière de matériel et de système d’exploitation au moment de l’exécution, utilisez la fonction [Terminal.supportsReadersOfType](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/supports-readers-of-type.html). Dans le cadre de l’initialisation du SDK Terminal, cette fonction nécessite que l’utilisateur final accepte les demandes d’autorisation d’accès à l’emplacement et au Bluetooth. Ce processus nécessite environ 10 millisecondes sur la plupart des appareils. ## Se connecter à un lecteur > Dans la version `5.0.0` du SDK Android, vous pouvez utiliser la méthode `easyConnect` pour combiner la détection du lecteur et la connexion en un seul appel à l’API afin de simplifier l’intégration. Pour en savoir plus, consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage). - [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) - [TapToPayConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-tap-to-pay-connection-configuration/index.html) Pour accepter les paiements Tap to Pay, communiquez le lecteur détecté au cours de l’étape précédente à la méthode `connectReader`. `connectReader` vérifie que l’appareil Android répond aux exigences suivantes : - Il n’est pas rooté et le bootloader de l’appareil est verrouillé et inchangé. - A installé une mise à jour de sécurité durant les 12 derniers mois - Utilise les services Google Mobile et dispose de l’application Google Play Store - Il dispose d’une connexion Internet stable - Il exécute le système d’exploitation fourni par le fabricant sans modification. - L’application utilise Tap to Pay SDK version 2.20.0 ou ultérieure. - Les options développeur sont désactivées pour la version non simulée du lecteur Tap to Pay. Si votre application s’exécute sur un appareil qui ne répond pas aux exigences ci-dessus, le rappel `onFailure` renvoie une erreur `TerminalException` contenant un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) et des informations supplémentaires. L’utilisateur final peut remédier à certains des [motifs d’échec](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html). Par exemple : - `STRIPE_API_CONNECTION_ERROR` : l’utilisateur peut se connecter à une source Internet stable. - `TAP_TO_PAY_UNSUPPORTED_ANDROID_VERSION` : l’utilisateur peut mettre à niveau son système d’exploitation, si une mise à jour est disponible auprès du fabricant de l’appareil. À la connexion, vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md). Pour ce faire, créez et utilisez une `TapToPayConnectionConfiguration` avec le `locationId` réglé sur l’ID de l’emplacement à associer lors de la connexion. #### Kotlin ```kotlin val tapToPayReaderListener = yourTapToPayReaderListener val autoReconnectOnUnexpectedDisconnect = true val config = TapToPayConnectionConfiguration( ""{{LOCATION_ID}}"", autoReconnectOnUnexpectedDisconnect, tapToPayReaderListener ), Terminal.getInstance().connectReader( firstReader, config, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` ## Gérer les déconnexions inattendues - [TapToPayReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-tap-to-pay-reader-listener/index.html) Des déconnexions inopinées peuvent survenir entre votre application et le lecteur. Le lecteur Tap to Pay peut par exemple se déconnecter de manière inattendue pour les raisons suivantes : - Le système d’exploitation Android met fin au service Tap to Pay du lecteur en raison de contraintes de mémoire. - L’appareil n’est plus connecté à Internet. Il y a deux façons de procéder : #### Tentative de reconnexion automatique Vous pouvez définir `autoReconnectOnUnexpectedDisconnect` sur `true` pour permettre au SDK de tenter automatiquement une reconnexion en cas de déconnexion inattendue. Le SDK adopte ce comportement par défaut si vous omettez ce paramètre. Vous pouvez également implémenter `TapToPayReaderListener` pour reconnecter automatiquement les rappels dans votre application. #### Kotlin ```kotlin val tapToPayReaderListener = yourTapToPayReaderListener val autoReconnectOnUnexpectedDisconnect = true Terminal.getInstance().connectReader( reader, TapToPayConnectionConfiguration( ""{{LOCATION_ID}}"", autoReconnectOnUnexpectedDisconnect, tapToPayReaderListener ), readerCallback, ) ``` Lorsque le SDK tente de se reconnecter automatiquement, les événements suivants se produisent : 1. En cas de déconnexion, le SDK tente automatiquement de se reconnecter et vous informe via `onReaderReconnectStarted`. Assurez-vous que votre application annonce que la connexion a été perdue et qu’une reconnexion est en cours. - Vous pouvez utiliser l’objet `Cancelable` pour arrêter la tentative de reconnexion à tout moment. 1. Si le SDK parvient à se reconnecter au lecteur, Stripe vous envoie une notification `onReaderReconnectSucceeded`. Assurez-vous que votre application signale à l’utilisateur que la connexion a été restaurée et qu’il peut reprendre ses opérations habituelles. 1. Si le SDK ne parvient pas à se reconnecter au lecteur, Stripe vous envoie une notification `onReaderReconnectFailed` et `TapToPayReaderListener.onDisconnect`. Assurez-vous que votre application signale à l’utilisateur qu’une déconnexion inattendue s’est produite. #### Kotlin ```kotlin class CustomTapToPayReaderListener : TapToPayReaderListener { override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time } override fun onReaderReconnectSucceeded(reader: Reader) { // 2. Notified when reader reconnection succeeds // App is now connected } override fun onReaderReconnectFailed(reader: Reader) { // 3. Notified when reader reconnection fails // App is now disconnected } } ``` #### Gérer la déconnexion manuellement Pour gérer vous-même la déconnexion, vous devez : 1. Définissez `autoReconnectOnUnexpectedDisconnect` sur `false` pour désactiver la reconnexion automatique par défaut. 1. Implémentez `TapToPayReaderListener` pour son rappel `onDisconnect`. Cela permet à votre application de se reconnecter au lecteur Tap to Pay et, le cas échéant, d’informer l’utilisateur du problème et de lui indiquer comment activer l’accès à Tap to Pay. Les utilisateurs finaux peuvent résoudre certaines erreurs, telles que les problèmes de connexion à Internet. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), TapToPayReaderListener { // ... override fun onDisconnect(reason: DisconnectReason) { // Consider displaying a UI to notify the user and start rediscovering readers } // ... } ``` > Si vous gérez la déconnexion manuellement sans désactiver la reconnexion automatique, cela peut provoquer des conflits qui interrompent la session du lecteur. # Tap to Pay sur React Native > This is a Tap to Pay sur React Native for when terminal-sdk-platform is react-native and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=tap-to-pay. Tap to Pay permet aux utilisateurs d’accepter des paiements sans contact par TPE avec des [appareils Android compatibles équipés de la technologie NFC](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices) ou des [iPhones compatibles](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices). Tap to Pay prend en charge les cartes sans contact Visa, Mastercard et American Express, ainsi que les portefeuilles mobiles NFC (Apple Pay, Google Pay et Samsung Pay). La prise en charge de Tap to Pay sur iPhone et Android est incluse dans les SDK Terminal natifs et permet d’effectuer des paiements directement depuis votre application mobile. > Dans la version `0.0.1-bêta.29` du SDK React Native, vous pouvez utiliser la méthode [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) pour combiner la découverte du lecteur et la connexion en un seul appel à l’API, afin de simplifier l’intégration. Suivez ces étapes pour connecter votre application au lecteur Tap to Pay sur un appareil compatible : - [Initialisez le SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) pour TTPA si vous utilisez le SDK sur un appareil Android. - [Détectez des lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) à l’aide du SDK pour confirmer la compatibilité des appareils. - [Connectez-vous à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) à l’aide du SDK pour accepter des paiements. - [Gérez les déconnexions inattendues](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) pour vous assurer que votre utilisateur puisse continuer à accepter des paiements si le lecteur se déconnecte de manière inattendue. ## Initialiser le SDK Tap to Pay sur Android fonctionne selon un processus dédié pour rendre les transactions plus sécurisées. Une deuxième instance de votre `Application` est alors créée. Pour éviter toute erreur inattendue causée par l’exécution de votre code sur un appareil Android, vous pouvez ignorer l’initialisation dans votre `Application` en consultant `TapToPay.isInTapToPayProcess()`. ```kotlin class MainApplication : Application(), ReactApplication { override fun onCreate() { super.onCreate() // Skip initialization if running in the TTPA process. if (TapToPay.isInTapToPayProcess()) return // For example, this will be skipped. TerminalApplicationDelegate.onCreate(this) } } ``` ## Détecter les lecteurs - [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) Utilisez la méthode `discoverReaders` pour déterminer la prise en charge matérielle de Tap to Pay sur votre appareil. Si vous exécutez votre application sur un appareil qui ne répond pas aux exigences ci-dessus, la méthode `discoverReaders` renvoie une erreur. ```js export default function DiscoverReadersScreen() { const { discoverReaders, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: (readers) => { // The `readers` variable will contain an array of all the discovered readers. }, }); useEffect(() => { const { error } = await discoverReaders({ discoveryMethod: 'tapToPay', }); }, [discoverReaders]); return ; } ``` ## Se connecter à un lecteur - [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) Pour accepter les paiements Tap to Pay, communiquez le lecteur détecté au cours de l’étape précédente à la méthode `connectReader`. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en l’associant à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, vous devez transmettre l’ID de l’emplacement correspondant à `connectReader`. Lorsque vous utilisez des [paiements indirects avec on_behalf_of](https://docs.stripe.com/terminal/features/connect.md?connect-charge-type=destination) sur iPhone, vous devez également fournir l’ID du compte connecté. ```js const { reader, error } = await connectReader({ discoveryMethod: 'tapToPay', reader: selectedReader, locationId: "{{LOCATION_ID}}", }); if (error) { console.log('connectTapToPayReader error:', error); return; } console.log('Reader connected successfully', reader); ``` ### Liens avec les comptes et conditions générales d’Apple La première fois que vous vous connectez au lecteur, vous voyez les conditions générales d’Apple Tap to Pay sur iPhone. Pour s’enregistrer auprès d’Apple, les commerçants doivent spécifier un ID Apple valide, qui sera utilisé pour leur entreprise, puis accepter les conditions énoncées par Apple. Vous n’avez besoin d’effectuer cette opération qu’une seule fois par compte Stripe. Le compte n’a pas besoin de répéter ce processus lors de connexions ultérieures, y compris sur d’autres appareils mobiles. Chaque compte connecté doit accepter les conditions générales si : - Un utilisateur Connect crée des paiements directs - Un utilisateur Connect crée un paiement indirect et spécifie un compte `on_behalf_of` ![Processus en trois étapes montrant la connexion avec l’Apple ID, l’acceptation des conditions et la confirmation de succès pour Tap to Pay sur iPhone.](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png) Associer votre compte Apple ID pour accepter les paiements Tap to Pay Tout iPhone peut utiliser jusqu’à 3 comptes Stripe uniques dans les applications au cours d’une période de 24 heures lors de l’appel de la méthode `connectReader` pour Tap to Pay sur iPhone. Si des comptes supplémentaires sont utilisés pour l’appareil au cours de la même période de 24 heures, la méthode `connectReader` génère une erreur [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked). Pour en savoir plus sur la liaison de comptes, consultez la section Informations de l’entreprise de la [FAQ d’Apple dédiée à Tap to Pay sur iPhone](https://register.apple.com/tap-to-pay-on-iphone/faq.html). ## Gérer les déconnexions inattendues - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT) Des déconnexions inattendues peuvent se produire entre votre application et le lecteur. Par exemple, le lecteur Tap to Pay peut se déconnecter de manière inattendue lorsque l’appareil perd la connexion à Internet et lorsque le système d’exploitation Android met fin au service de lecteur Tap to Pay en raison de contraintes de mémoire. Lors de la phase de test, vous pouvez simuler une déconnexion inattendue en désactivant l’accès à Internet sur votre appareil. #### Tentative de reconnexion automatique Vous pouvez définir `autoReconnectOnUnexpectedDisconnect` sur `true` pour permettre au SDK de tenter automatiquement une reconnexion en cas de déconnexion inattendue. Le SDK adopte ce comportement par défaut si vous omettez ce paramètre. ```js const { reader, error } = await connectReader({ discoveryMethod: 'tapToPay', reader, autoReconnectOnUnexpectedDisconnect: true, // default setting }); if (error) { console.log('connectReader error:', error); return; } console.log('Reader connected successfully', reader); ``` Lorsque le SDK tente de se reconnecter automatiquement, les événements suivants se produisent : 1. Le SDK vous envoie la notification `onDidStartReaderReconnect`. Assurez-vous que votre application annonce que la connexion a été perdue et qu’une reconnexion est en cours. - Vous pouvez utiliser l’objet `cancelReaderReconnection` pour arrêter la tentative de reconnexion à tout moment. 1. Si le SDK parvient à se reconnecter au lecteur, Stripe vous envoie une notification `onDidSucceedReaderReconnect`. Assurez-vous que votre application signale à l’utilisateur que la connexion a été restaurée et qu’il peut reprendre ses opérations habituelles. 1. Si le SDK ne parvient pas à se reconnecter au lecteur, Stripe vous envoie une notification `onDidFailReaderReconnect` et `onDidDisconnect`. Assurez-vous que votre application signale à l’utilisateur qu’une déconnexion inattendue s’est produite. ```js const { discoverReaders, connectedReader, discoveredReaders } = useStripeTerminal({ onDidStartReaderReconnect: (disconnectReason) => { // 1. Notified at the start of a reconnection attempt // Use cancelable to stop reconnection at any time }, onDidSucceedReaderReconnect: () => { // 2. Notified when reader reconnection succeeds // App is now connected }, onDidFailReaderReconnect: () => { // 3. Notified when reader reconnection fails // App is now disconnected } }); ``` #### Gérer la déconnexion manuellement Pour gérer vous-même la déconnexion, vous devez : 1. Définissez `autoReconnectOnUnexpectedDisconnect` sur `false` pour désactiver la reconnexion automatique par défaut. 1. Implémentez le rappel `onDidReportUnexpectedReaderDisconnect`. Cela permet à votre application de se reconnecter au lecteur Tap to Pay et, le cas échéant, d’informer l’utilisateur du problème et de lui indiquer comment activer l’accès à Tap to Pay. Les utilisateurs finaux peuvent résoudre certaines erreurs, telles que les problèmes de connexion à Internet. ```js const { discoverReaders, connectedReader, discoveredReaders } = useStripeTerminal({ onDidReportUnexpectedReaderDisconnect: (readers) => { // Consider displaying a UI to notify the user and start rediscovering readers }, }); ``` > Si vous gérez la déconnexion manuellement sans désactiver la reconnexion automatique, cela peut provoquer des conflits qui interrompent la session du lecteur. ## Prochaines étapes Vous avez connecté votre application au lecteur. Vous pouvez maintenant [encaisser votre premier paiement avec Stripe Terminal](https://docs.stripe.com/terminal/payments/collect-card-payment.md). Les nom et logo BBPOS et Chipper™ sont des marques ou marques déposées de BBPOS Limited aux États-Unis et/ou dans d’autres pays. Les nom et logo Verifone® sont des marques ou marques déposées de Verifone aux États-Unis et/ou dans d’autres pays. L’utilisation de ces marques n’implique aucune approbation de la part de BBPOS ou Verifone.