# Se connecter à un lecteur Associez 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, ce qui vous permet de développer et tester votre application et simuler les paiements Terminal, sans vous connecter à un appareil physique. ## Créer un lecteur de simulation Pour créer un lecteur de simulation, utilisez l’un des codes d’inscription désignés (`simulated-wpe`, `simulated-s700` ou `simulated-s710`) lors de l’enregistrement du lecteur. Ce code d’inscription crée un objet lecteur WisePOS E, Stripe S700 ou lecteur Stripe S710 de simulation dans un bac à sable uniquement. Vous pouvez enregistrer le lecteur de simulation à 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 du [point de terminaison 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 de simulation ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez le voir fonctionner lorsque les appels à la trousse SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour les trousses SDK simulent automatiquement la présentation des cartes si nécessaire. En ce qui concerne 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 d’un 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 collecter votre mode 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 de simulation ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez le voir fonctionner lorsque les appels à la trousse SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour les trousses SDK simulent automatiquement la présentation des cartes si nécessaire. En ce qui concerne 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. Lors de la connexion à un lecteur mobile ou à un lecteur Paiement rapide, votre intégration doit inclure le paramètre `locationId` dans la configuration de la connexion, même pour le lecteur de simulation. Étant donné que le lecteur de simulation ne peut pas être associé à un emplacement réel, fournissez le `locationId` fictif de ce dernier. ```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 d’un 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 collecter votre mode 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 de simulation ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez le voir fonctionner lorsque les appels à la trousse SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour les trousses SDK simulent automatiquement la présentation des cartes si nécessaire. En ce qui concerne 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. Lors de la connexion à un lecteur mobile, votre intégration doit inclure le paramètre `locationId` dans la configuration de la connexion, même pour le lecteur de simulation. Étant donné que le lecteur de simulation ne peut pas être associé à un emplacement réel, fournissez le `locationId` fictif de ce dernier. ```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 d’un 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 collecter votre mode 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 de simulation ne fournit pas d’interface utilisateur. Après vous y être connecté(e) dans votre application, vous pouvez le voir fonctionner lorsque les appels à la trousse SDK ou à l’API Stripe aboutissent. Les lecteurs simulés pour les trousses SDK simulent automatiquement la présentation des cartes si nécessaire. En ce qui concerne 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-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) pour rechercher des lecteurs, avec l’option `simulated` définie à `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 de simulation. Lors de la connexion à un lecteur mobile ou à un lecteur Paiement rapide, votre intégration doit inclure le paramètre `locationId` dans la configuration de la connexion, même pour le lecteur de simulation. Étant donné que le lecteur de simulation ne peut pas être associé à un emplacement réel, fournissez le `locationId` fictif de ce dernier. ```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 d’un 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 collecter votre mode 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 `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 parmi de nombreux autres lecteurs. Une fois que la trousse SDK a détecté un lecteur, elle ne passe pas à un lecteur plus proche, à moins de désactiver le lecteur détecté. Notez que lorsque vous utilisez la proximité Bluetooth, la trousse 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, ce qui permet à l’utilisateur de confirmer la connexion au lecteur ou de l’annuler s’il ne souhaite pas utiliser ce lecteur. #### Balayage Bluetooth Le balayage 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 de lecteurs les plus proches. Au cours du processus de recherche, le `SCPConnectionStatus` du Terminal passe à `SCPConnectionStatus.SCPConnectionStatusDiscovering` pendant que la détection est en cours. La méthode de découverte par balayage Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de balayage. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur si aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste mise à jour automatiquement des lecteurs détectés avec leurs numéros de série 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étection des lecteurs. Si vous devez afficher des noms conviviaux pour les lecteurs, conservez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Appairage Bluetooth Pour améliorer la sécurité et respecter les réglementations de l’UE, à partir de novembre 2025, Stripe utilise le processus d’appairage Bluetooth par comparaison numérique pour les lecteurs de cartes WisePad 3. Le processus de comparaison numérique exige que vous vérifiiez une clé d’accès à la fois sur votre lecteur de cartes et sur l’appareil PDV lors de l’appairage. 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 les étapes suivantes lorsque vous associez votre WisePad 3 à une nouvelle application mobile. Une fois que votre appareil PDV a découvert et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond à la fois sur le WisePad 3 et sur l’appareil PDV. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Appairer** sur votre appareil PDV. > #### Remarques > > Vous ne devez procéder à l’appairage par comparaison numérique que lorsque vous appairez un WisePad 3 avec un nouvel appareil PDV, ou lorsque vous l’appairez à nouveau avec un appareil PDV 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. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, créez et utilisez une configuration `BluetoothConnectionConfiguration` avec le `locationId` défini sur l’ID de l’emplacement approprié 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 du lecteur - [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 , s’il est hors de portée ou si sa batterie est déchargée. Vous pouvez simuler une connexion inattendue lors d’un test en éteignant le lecteur. Le `MobileReaderDelegate` comprend une méthode `reader:didDisconnect:` qui fournit à votre application le `DisconnectReason` pour permettre d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour gérer 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 associé - [rebootReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)rebootReader:.html) Le lecteur M2 de Stripe et BBPOS WisePad 3 redémarrent automatiquement après 24 heures de fonctionnement. Cependant, vous pouvez forcer le lecteur à redémarrer et réinitialiser la minuterie de 24 heures à l’aide de l’API `rebootReader`. Après avoir effectué cette opération, le lecteur se déconnecte de la trousse SDK, puis redémarre. Si vous utilisez la reconnexion automatique, la trousse SDK tentera 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. } } ``` #### Tenter automatiquement de se reconnecter 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. Mettez en œuvre les rappels de reconnexion du lecteur dans le `MobileReaderDelegate`. 1. Transmettez le `MobileReaderDelegate` à votre `BluetoothConnectionConfiguration`. 1. Lorsque la trousse 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 la trousse 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 la trousse 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 : - Les configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - Mises à jour de sécurité L’installation des mises à jour obligatoires commence 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 les mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque des mises à jour devant être effectuées immédiatement sont disponibles pour le lecteur, le `MobileReaderDelegate` de l’intégration reçoit le rappel `didStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. Le `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation du temps d’installation requis, indiqué par `durationEstimate`. Au cours du processus d’installation de la mise à jour sur le lecteur, le `connectionStatus` de Terminal passe à l’état `connecting`. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et en 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 le lieu au cours des 30 derniers jours. - La version de la trousse SDK iOS est supérieure ou égale à `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour 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 la connexion au lecteur. Vous ne pouvez pas annuler les mises à jour incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date spécifiée, après quoi elles deviennent obligatoires. La trousse SDK vous informe des mises à jour facultatives par l’intermédiaire du `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é de la mise à jour (`durationEstimate`) - Horodatage après lequel la mise à jour devient obligatoire (`requiredAt`) Dans votre application, informez les utilisateurs qu’une mise à jour est disponible et affichez une invite pour poursuivre la mise à jour. Pour procéder à la mise à jour précédemment signalée avec `didReportAvailableUpdate`, appelez `Terminal.shared.installAvailableUpdate`. La mise à jour est également enregistré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` fait état de la progression de la mise à jour dans la méthode `didReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, celle-ci est installée lors de la prochaine connexion du lecteur. #### 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 découvrir comment vérifier si votre application gère les différents types de mises à jour possibles pour un lecteur, consultez la section [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. } } ``` #### Balayage Bluetooth Le balayage 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 de lecteurs les plus proches. Au cours du processus de recherche, le `connectionStatus` du Terminal passe à `ConnectionStatus.DISCOVERING` pendant que la détection est en cours. La méthode de découverte par balayage Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de balayage. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur si aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste mise à jour automatiquement des lecteurs détectés avec leurs numéros de série 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étection des lecteurs. Si vous devez afficher des noms conviviaux pour les lecteurs, conservez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Appairage Bluetooth Pour améliorer la sécurité et respecter les réglementations de l’UE, à partir de novembre 2025, Stripe utilise le processus d’appairage Bluetooth par comparaison numérique pour les lecteurs de cartes WisePad 3. Le processus de comparaison numérique exige que vous vérifiiez une clé d’accès à la fois sur votre lecteur de cartes et sur l’appareil PDV lors de l’appairage. 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 les étapes suivantes lorsque vous associez votre WisePad 3 à une nouvelle application mobile. Une fois que votre appareil PDV a découvert et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond à la fois sur le WisePad 3 et sur l’appareil PDV. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Appairer** sur votre appareil PDV. > #### Remarques > > Vous ne devez procéder à l’appairage par comparaison numérique que lorsque vous appairez un WisePad 3 avec un nouvel appareil PDV, ou lorsque vous l’appairez à nouveau avec un appareil PDV 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. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, créez et utilisez une configuration `BluetoothConnectionConfiguration` 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 = 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 du lecteur - [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 , s’il est hors de portée ou si sa batterie est déchargée. Vous pouvez simuler une connexion inattendue lors d’un test en éteignant le lecteur. Le `MobileReaderListener` comprend un rappel `onDisconnect` qui fournit à votre application le `DisconnectReason` pour permettre d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour gérer 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 associé - [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html) Le lecteur M2 de Stripe et BBPOS WisePad 3 redémarrent automatiquement après 24 heures de fonctionnement. Cependant, vous pouvez forcer le lecteur à redémarrer et réinitialiser la minuterie de 24 heures à l’aide de l’API `rebootReader`. Après avoir effectué cette opération, le lecteur se déconnecte de la trousse SDK, puis redémarre. Si vous utilisez la reconnexion automatique, la trousse SDK tentera 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 } } ) ``` #### Tenter automatiquement de se reconnecter 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. Mettez en œuvre les rappels de reconnexion du lecteur dans le `MobileReaderListener`. 1. Transmettez le `MobileReaderListener` à votre `BluetoothConnectionConfiguration`. 1. Lorsque la trousse 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 la trousse 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 la trousse SDK ne peut pas se reconnecter au lecteur et envoie [`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 : - Les configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - Mises à jour de sécurité L’installation des mises à jour obligatoires commence 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 les mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque des mises à jour devant être effectuées immédiatement sont disponibles pour le lecteur, le `MobileReaderListener` de l’intégration reçoit `onStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. Le `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation du temps d’installation requis, indiqué par `durationEstimate`. Au cours du processus d’installation de la mise à jour sur le lecteur, le `connectionStatus` de Terminal passe à l’état `ConnectionStatus.CONNECTING`. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et en 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 le lieu au cours des 30 derniers jours. - La version de la trousse SDK Android est supérieure ou égale à `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour 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 la connexion au lecteur. Vous ne pouvez pas annuler les mises à jour incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date spécifiée, après quoi elles deviennent obligatoires. La trousse SDK vous informe des mises à jour facultatives par l’intermédiaire du `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é de la mise à jour (`durationEstimate`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, informez les utilisateurs qu’une mise à jour est disponible et affichez une invite pour poursuivre la mise à jour. Pour procéder à la mise à jour précédemment signalée avec `onReportAvailableUpdate`, appelez `Terminal.getInstance().installAvailableUpdate`. La mise à jour est également enregistré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` fait état de la progression de la mise à jour dans la méthode `onReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, celle-ci est installée lors de la prochaine connexion du lecteur. #### 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 découvrir comment vérifier si votre application gère les différents types de mises à jour possibles pour un lecteur, consultez la section [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 ; } ``` #### Balayage Bluetooth Le balayage 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, la trousse SDK continue à invoquer `onUpdateDiscoveredReaders` dans le hook `useStripeTerminal` avec la dernière liste de lecteurs les plus proches. La méthode de découverte par balayage Bluetooth vous permet de définir un délai d’expiration afin de limiter la durée de balayage. Cela permet d’économiser la batterie de l’appareil ou de déclencher un message d’erreur si aucun appareil n’est trouvé. Dans votre application mobile, nous vous recommandons d’afficher une liste mise à jour automatiquement des lecteurs détectés avec leurs numéros de série 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étection des lecteurs. Si vous devez afficher des noms conviviaux pour les lecteurs, conservez votre propre mappage des numéros de série aux étiquettes dans votre application. #### Appairage Bluetooth Pour améliorer la sécurité et respecter les réglementations de l’UE, à partir de novembre 2025, Stripe utilise le processus d’appairage Bluetooth par comparaison numérique pour les lecteurs de cartes WisePad 3. Le processus de comparaison numérique exige que vous vérifiiez une clé d’accès à la fois sur votre lecteur de cartes et sur l’appareil PDV lors de l’appairage. 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 les étapes suivantes lorsque vous associez votre WisePad 3 à une nouvelle application mobile. Une fois que votre appareil PDV a découvert et affiché le lecteur WisePad 3 : 1. Vérifiez que le code à 6 chiffres correspond à la fois sur le WisePad 3 et sur l’appareil PDV. 1. Sélectionnez **Confirmer** sur le WisePad 3. 1. Sélectionnez **Appairer** sur votre appareil PDV. > #### Remarques > > Vous ne devez procéder à l’appairage par comparaison numérique que lorsque vous appairez un WisePad 3 avec un nouvel appareil PDV, ou lorsque vous l’appairez à nouveau avec un appareil PDV 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) à 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 du lecteur - [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 , s’il est hors de portée ou si sa batterie est déchargée. Vous pouvez simuler une connexion inattendue lors d’un test en éteignant le lecteur. L’objet `UserCallbacks` comprend l’objet `onDidDisconnect` qui fournit à votre application l’objet `DisconnectReason` qui permet d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour gérer 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 associé - [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader) Le lecteur M2 de Stripe et BBPOS WisePad 3 redémarrent automatiquement après 24 heures de fonctionnement. Cependant, vous pouvez forcer le lecteur à redémarrer et réinitialiser la minuterie de 24 heures à l’aide de l’API `rebootReader`. Après avoir effectué cette opération, le lecteur se déconnecte de la trousse SDK, puis redémarre. Si vous utilisez la reconnexion automatique, la trousse SDK tentera 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'); ``` #### Tenter automatiquement de se reconnecter 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. Définissez `autoReconnectOnUnexpectedDisconnect` à true dans `ConnectBluetoothReaderParams`. 1. Mettez en œuvre les rappels de reconnexion automatique qui se trouvent dans l’objet `UserCallbacks`. 1. Lorsque la trousse 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 arrêter la tentative de reconnexion à tout moment. 1. Lorsque la trousse SDK indique que la reconnexion a fonctionné en envoyant `onDidSucceedReaderReconnect`, affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si la trousse 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 : - Les configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - Mises à jour de sécurité L’installation des mises à jour obligatoires commence 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 les mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque des mises à jour devant être effectuées immédiatement 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 du temps d’installation requis, indiqué par `estimatedUpdateTime`. Au cours du processus d’installation de la mise à jour sur le lecteur, le `connectionStatus` de Terminal passe à l’état `"connecting"`. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et en 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 le lieu au cours des 30 derniers jours. - La version de la trousse SDK React Native est supérieure ou égale à `0.0.1-beta.18`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour 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 incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date spécifiée, après quoi elles deviennent obligatoires. La trousse SDK vous informe des mises à jour facultatives par l’intermédiaire du 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, y compris : - Temps estimé de la mise à jour (`estimatedUpdateTime`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, informez les utilisateurs qu’une mise à jour est disponible et affichez une invite pour poursuivre la mise à jour. Pour procéder à la mise à jour précédemment signalée avec `onDidReportAvailableUpdate`, appelez `installAvailableUpdate` depuis le hook `useStripeTerminal`. La mise à jour est également enregistré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` fait état de la progression de la mise à jour dans la méthode `onDidReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, celle-ci est installée lors de la prochaine connexion du lecteur. ```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 découvrir comment vérifier si votre application gère les différents types de mises à jour possibles pour un lecteur, consultez la section [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 Stripe Terminal Android SDK 3.0.0 (ou une version ultérieure) afin de prendre en charge les connexions USB pour les lecteurs [Stripe M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) et le [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 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 d’un câble USB : 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). ## 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) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, , créez et utilisez un objet `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 du lecteur - [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 connecte à votre appareil est déconnecté. Vous pouvez simuler une connexion inattendue lors d’un test en éteignant le lecteur. Le `MobileReaderListener` comprend un rappel `onDisconnect` qui fournit à votre application le `DisconnectReason` pour permettre d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour gérer 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 associé - [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html) Le lecteur M2 de Stripe et BBPOS WisePad 3 redémarrent automatiquement après 24 heures de fonctionnement. Cependant, vous pouvez forcer le lecteur à redémarrer et réinitialiser la minuterie de 24 heures à l’aide de l’API `rebootReader`. Après avoir effectué cette opération, le lecteur se déconnecte de la trousse SDK, puis redémarre. Si vous utilisez la reconnexion automatique, la trousse SDK tentera 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 } } ) ``` #### Tenter automatiquement de se reconnecter 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. Mettez en œuvre les rappels de reconnexion du lecteur dans le `MobileReaderListener`. 1. Transmettez le `MobileReaderListener` à votre `UsbConnectionConfiguration`. 1. Lorsque la trousse 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 la trousse 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 la trousse SDK ne peut pas se reconnecter au lecteur et envoie [`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 : - Les configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - Mises à jour de sécurité L’installation des mises à jour obligatoires commence 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 les mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque des mises à jour devant être effectuées immédiatement sont disponibles pour le lecteur, le `MobileReaderListener` de l’intégration reçoit `onStartInstallingUpdate` avec un `ReaderSoftwareUpdate`. Le `ReaderSoftwareUpdate` fournit les détails nécessaires de la mise à jour, y compris une estimation du temps d’installation requis, indiqué par `durationEstimate`. Au cours du processus d’installation de la mise à jour sur le lecteur, le `connectionStatus` de Terminal passe à l’état `ConnectionStatus.CONNECTING`. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et en 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 le lieu au cours des 30 derniers jours. - La version de la trousse SDK Android est supérieure ou égale à `3.5.0`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour 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 la connexion au lecteur. Vous ne pouvez pas annuler les mises à jour incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date spécifiée, après quoi elles deviennent obligatoires. La trousse SDK vous informe des mises à jour facultatives par l’intermédiaire du `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é de la mise à jour (`durationEstimate`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, informez les utilisateurs qu’une mise à jour est disponible et affichez une invite pour poursuivre la mise à jour. Pour procéder à la mise à jour précédemment signalée avec `onReportAvailableUpdate`, appelez `Terminal.getInstance().installAvailableUpdate`. La mise à jour est également enregistré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` fait état de la progression de la mise à jour dans la méthode `onReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, celle-ci est installée lors de la prochaine connexion du lecteur. #### 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 découvrir comment vérifier si votre application gère les différents types de mises à jour possibles pour un lecteur, consultez la section [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 de la trousse SDK React Native est actuellement limitée à la plateforme Android. Utilisez le Stripe Terminal React Native SDK beta.13 (ou une version ultérieure) afin de prendre en charge les connexions USB pour les lecteurs [Stripe M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) et le [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 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 d’un câble USB : 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). ## 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) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, transmettez l’objet `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 du lecteur - [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 connecte à votre appareil est déconnecté. Vous pouvez simuler une connexion inattendue lors d’un test en éteignant le lecteur. L’objet `UserCallbacks` comprend l’objet `onDidDisconnect` qui fournit à votre application l’objet `DisconnectReason` qui permet d’identifier la raison pour laquelle le lecteur s’est déconnecté. Pour gérer 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 associé - [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader) Le lecteur M2 de Stripe et BBPOS WisePad 3 redémarrent automatiquement après 24 heures de fonctionnement. Cependant, vous pouvez forcer le lecteur à redémarrer et réinitialiser la minuterie de 24 heures à l’aide de l’API `rebootReader`. Après avoir effectué cette opération, le lecteur se déconnecte de la trousse SDK, puis redémarre. Si vous utilisez la reconnexion automatique, la trousse SDK tentera 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'); ``` #### Tenter automatiquement de se reconnecter 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. Définissez `autoReconnectOnUnexpectedDisconnect` à true dans `ConnectUsbReaderParams`. 1. Mettez en œuvre les rappels de reconnexion automatique qui se trouvent dans l’objet `UserCallbacks`. 1. Lorsque la trousse 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 arrêter la tentative de reconnexion à tout moment. 1. Lorsque la trousse SDK indique que la reconnexion a fonctionné en envoyant `onDidSucceedReaderReconnect`, affichez un message indiquant que la connexion a été rétablie et que le lecteur fonctionne normalement. 1. Si la trousse 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 : - Les configurations régionales qui vous permettent de rester en règle avec les exigences des réseaux de cartes et des émetteurs - Mises à jour de sécurité L’installation des mises à jour obligatoires commence 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 les mises à jour, le niveau de la batterie du lecteur doit être supérieur à 50 %. ### Mises à jour requises Lorsque des mises à jour devant être effectuées immédiatement 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 du temps d’installation requis, indiqué par `estimatedUpdateTime`. Au cours du processus d’installation de la mise à jour sur le lecteur, le `connectionStatus` de Terminal passe à l’état `"connecting"`. Votre application doit avertir les utilisateurs qu’une mise à jour est en cours d’installation et en 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 le lieu au cours des 30 derniers jours. - La version de la trousse SDK React Native est supérieure ou égale à `0.0.1-beta.18`. Si les conditions sont remplies, le processus de connexion aboutit, bien que la mise à jour 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 incrémentielles en cours. ### Mises à jour facultatives Vous pouvez reporter les mises à jour facultatives jusqu’à la date spécifiée, après quoi elles deviennent obligatoires. La trousse SDK vous informe des mises à jour facultatives par l’intermédiaire du 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, y compris : - Temps estimé de la mise à jour (`estimatedUpdateTime`) - Date après laquelle la mise à jour devient obligatoire (`requiredAt`) Dans votre application, informez les utilisateurs qu’une mise à jour est disponible et affichez une invite pour poursuivre la mise à jour. Pour procéder à la mise à jour précédemment signalée avec `onDidReportAvailableUpdate`, appelez `installAvailableUpdate` depuis le hook `useStripeTerminal`. La mise à jour est également enregistré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` fait état de la progression de la mise à jour dans la méthode `onDidReportReaderSoftwareUpdateProgress`. Lorsque la date `requiredAt` d’une mise à jour facultative est dépassée, celle-ci est installée lors de la prochaine connexion du lecteur. ```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 découvrir comment vérifier si votre application gère les différents types de mises à jour possibles pour un lecteur, consultez la section [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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer 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. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 tapez 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, veuillez dresser la liste de 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 à partir de votre point de vente. Vous pouvez récupérer les ID de lecteurs à l’aide du point de terminaison [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, comme 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 nécessite que votre point de vente et votre lecteur se trouvent sur le même réseau local avec un DNS local fonctionnel. L’intégration pilotée par serveur utilise plutôt l’API Stripe, qui peut être plus simple dans les environnements réseau complexes. Consultez notre [comparatif des plateformes ](https://docs.stripe.com/terminal/payments/setup-reader.md#sdk) pour vous aider à choisir celle qui correspond le mieux à 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 à l’aide de la méthode `discoverReaders`, en définissant `discoveryMethod` sur `Internet`. Vous pouvez affiner vos résultats 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 exigent une autorisation explicite avant que les sites Web puissent accéder aux périphériques réseau locaux (tels que les lecteurs de terminaux) lors de l’utilisation du SDK JavaScript Stripe Terminal. Pour tout savoir sur les étapes de configuration et la résolution des problèmes, [consultez les instructions 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 [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) en indiquant 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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée 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` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `processPayment` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse SDK, mais qu’il est inactif (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 sur false (par défaut) | fail_if_in_use est sur true | | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, autorisez vos utilisateurs à réessayer la connexion avec `fail_if_in_use` définie sur `false` si la connexion échoue la première fois. Avec cette configuration, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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 déployer le rappel `onUnexpectedReaderDisconnect` afin de remédier à toute déconnexion du lecteur. Lorsque vous déployez ce rappel, affichez une interface utilisateur qui informe l’utilisateur que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et lancer 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 recherche 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 à connecter à votre application de point de vente par l’entremise de `discoverReaders`, à l’aide de `InternetDiscoveryConfiguration`. Vous pouvez affiner vos résultats 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étection de lecteurs intelligents, la méthode `DiscoveryDelegate.didUpdateDiscoveredReaders` n’est appelée qu’une fois par appel à `discoverReaders`. `didUpdateDiscoveredReaders` renvoie une liste de lecteurs vide si aucun lecteur n’est enregistré ou si aucun lecteur n’est associé à l’emplacement donné. Si vous faites un appel ultérieur à `discoverReaders` pour actualiser la liste, vous devez d’abord annuler l’appel précédent avec le `Cancelable` retourné par `discoverReaders`. `InternetDiscoveryConfiguration` prend en charge une valeur `timeout` facultative 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 à l’API pour une intégration plus simple. Consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) pour en savoir plus. Pour connecter votre application de point de vente à un lecteur, appelez `connect Reader` en indiquant le lecteur sélectionné, à l’aide de `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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée se déconnecte du lecteur. La méthode `connectReader` 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 `connectReader` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse 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, et 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 sur false (par défaut) | failIfInUse est sur true | | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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. Lorsque vous déployez ce rappel, affichez une interface utilisateur qui informe l’utilisateur que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et lancer 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 recherche 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 à connecter à votre application de point de vente par l’entremise de `discoverReaders`, à l’aide de `InternetDiscoveryConfiguration`. Vous pouvez affiner vos résultats 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. Consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage) pour en savoir plus. Pour connecter votre application de point de vente à un lecteur, appelez `connect Reader` en indiquant le lecteur sélectionné, à l’aide de `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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée se déconnecte du lecteur. La méthode `connectReader` 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 `connectReader` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse 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, et 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 sur false (par défaut) | failIfInUse est sur true | | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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. Lorsque vous déployez ce rappel, affichez une interface utilisateur qui informe l’utilisateur que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et lancer 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 recherche 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 à l’aide de la méthode `discoverReaders`, en définissant `discoveryMethod` sur `Internet`. Vous pouvez affiner vos résultats 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` de la trousse 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étection du lecteur et la connexion en un seul appel à l’API pour une intégration plus simple. Pour connecter votre application de point de vente à un lecteur, appelez `connectReader` en indiquant 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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée se déconnecte du lecteur. La méthode `connectReader` 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 `connectReader` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse 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, et 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 sur false (par défaut) | failIfInUse est sur true | | -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `connectInternetReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `connectInternetReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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 mettre en œuvre le rappel `onDidDisconnect` pour gérer la dissociation d’un lecteur. Lorsque vous implémentez ce rappel, affichez une interface utilisateur qui informe votre utilisateur que le lecteur a été dissocié. Vous pouvez invoquer `discoverReaders` pour rechercher les 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 recherche 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 à connecter à votre application de point de vente par l’entremise de `discoverReaders`, à l’aide de `InternetDiscoveryConfiguration`. Vous pouvez affiner vos résultats 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étection du lecteur et la connexion en un seul appel à l’API pour une intégration plus simple. Pour connecter votre application de point de vente à un lecteur, appelez `connect Reader` en indiquant le lecteur sélectionné, à l’aide de `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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `connectReader` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée se déconnecte du lecteur. La méthode `connectReader` 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 `connectReader` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `collectPaymentMethod` ou `confirmPaymentIntent` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse 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, et 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 sur false (par défaut) | failIfInUse est sur true | | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `connectReader` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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. Lorsque vous déployez ce rappel, affichez une interface utilisateur qui informe l’utilisateur que le lecteur est déconnecté. Vous pouvez appeler `discoverReaders` pour rechercher des lecteurs et lancer 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 Shared 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 recherche 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 la trousse SDK. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse 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 le lecteur**. 1. Si vous disposez d’un [lecteur intelligent](https://docs.stripe.com/terminal/smart-readers.md), saisissez la séquence de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez sur **Générer un code d’association**. 1. Saisissez le code d’enregistrement, puis cliquez sur **Suivant**. 1. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 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 le lecteur**. 1. Trouvez le numéro de série sur 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. Si vous le souhaitez, vous pouvez 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 un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de votre lecteur. #### Enregistrer par commande de matériel 1. Dans la page [Commandes de matériel](https://dashboard.stripe.com/terminal/hardware_orders), recherchez une commande dont l’état est “expédié” ou “livré”. Cliquez sur le menu d’options supplémentaires ⋯) au bout de la ligne, puis cliquez sur **Enregistrer**. 1. Sur la page **Enregistrer les lecteurs**, sélectionnez un ou plusieurs lecteurs dans la commande de matériel à enregistrer, puis cliquez sur **Enregistrer**. 1. Si vous le souhaitez, choisissez un nom pour le lecteur. Si vous avez sélectionné plusieurs lecteurs, le nom sert de préfixe et nous nommons les lecteurs séquentiellement (par exemple, pour une entrée donnée de « Lecteur de test », nous nommons les lecteurs « Lecteur de test 1 », « Lecteur de test 2 », etc.). 1. Si vous avez déjà créé un emplacement, sélectionnez le nouvel emplacement du lecteur. Sinon, créez un Emplacement en cliquant sur **+ Ajouter nouveau**. 1. Cliquez sur **Enregistrer** pour terminer l’enregistrement de vos lecteurs. #### L'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 qui permet 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 de touches `0-7-1-3-9` pour afficher un code d’enregistrement unique. Si vous disposez d’un lecteur BBPOS WisePOS E ou d’un lecteur Stripe S700/S710, accédez aux [paramètres du lecteur](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) puis tapez 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, veuillez dresser la liste de 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 vos résultats 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 l’application de votre point de vente à un lecteur, appelez `ConnectInternetReaderAsync` en indiquant 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 de la trousse SDK Stripe Terminal peut se connecter à un lecteur à la fois. Par défaut, lorsque vous appelez `ConnectInternetReaderAsync` depuis une autre application, la connexion entrante remplace la connexion existante entre la trousse SDK et le lecteur, et la trousse SDK précédemment connectée 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` a un comportement alternatif dans lequel la connexion entrante échoue lorsque le lecteur est au milieu d’un appel `CollectPaymentMethodAsync` ou `ConfirmPaymentIntentAsymc` lancé par une autre trousse SDK. Si le lecteur est connecté à une autre trousse SDK, mais qu’il est inactif (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 sur false (par défaut) | FailIfInUse est sur true | | ------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `ConnectInternetReaderAsync` appelé depuis une nouvelle trousse SDK lorsque le lecteur est inactif. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | | `ConnectInternetReaderAsync` appelé depuis une nouvelle trousse SDK lorsque le lecteur est en train d’effectuer une transaction | La connexion existante entre le SDK et le lecteur 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 l’application est invoquée. | La connexion entrante échoue avec une erreur de lecteur. La connexion 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, l’un de vos utilisateurs ne peut pas interrompre accidentellement une transaction en se connectant par inadvertance à un lecteur en cours d’utilisation, mais peut 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 déployer le rappel `OnUnexpectedReaderDisconnect` afin de remédier à toute déconnexion du lecteur. Lorsque vous déployez ce rappel, affichez une interface utilisateur qui informe l’utilisateur que le lecteur est déconnecté. Vous pouvez appeler `DiscoverReadersAsync` pour rechercher les lecteurs et lancer 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 sa connexion réseau. Afin de simuler une déconnexion inopinée, é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 recherche et de connexion, vous pouvez afficher un message d’interface utilisateur indiquant qu’une reconnexion automatique est en cours. # Paiement rapide sur iPhone > This is a Paiement rapide 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. Le Paiement rapide sur iPhone permet aux utilisateurs d’accepter des paiements sans contact en personne avec un [iPhone compatible](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) et le [Stripe Terminal SDK](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios). Le Paiement rapide sur iPhone prend en charge les cartes Visa, Mastercard, American Express, Discover, les cartes sans contact et les portefeuilles numériques NFC (Apple Pay, Google Pay et Samsung Pay). Le Paiement rapide sur iPhone est inclus dans la trousse SDK Terminal iOS et permet les paiements 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` sera appelé avec une erreur si votre application est exécutée sur un appareil qui ne répond pas aux [critères de l’appareil pris en charge](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 } } ``` ## Me 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 à l’API pour une intégration plus simple. Consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) pour en savoir plus. - [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 effectués avec Paiement rapide sur iPhone, transmettez le lecteur détecté à la méthode `connectReader`. Vous devrez également [créer une méthode de délégation](https://docs.stripe.com/terminal/payments/connect-reader.md#device-setup) pour gérer les éventuelles mises à jour du lecteur. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, créez un `SCPTapToPayConnectionConfiguration` et utilisez-le avec le `locationId` défini à l’ID d’emplacement approprié lors de la connexion. Définissez le `display_name` pour qu’il représente le nom de l’entreprise lors de la création d’un emplacement. Votre client voit le `display_name` de l’emplacement être affiché sur l’écran tactile de l’appareil, à moins que vous 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 devrez é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 Paiement rapide 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 des entreprises. Assurez-vous que votre application mette en œuvre `SCPTapToPayReaderDelegate` pour gérer les étapes de configuration et afficher un message à l’intention de votre entreprise afin qu’elle reste en attente. Les étapes de configuration sont comparables à un processus de mise à jour logicielle, et vous pourrez 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 d’Apple Tous les utilisateurs doivent accepter les conditions d’utilisation du Paiement rapide sur iPhone d’Apple avant d’accepter le paiement pour la première fois. Pour les utilisateurs Connect, chaque compte connecté doit accepter individuellement les conditions générales lorsque : - Un utilisateur Connect crée des paiements directs - Un utilisateur Connect crée un paiement indirect et précise un compte `on_behalf_of` Les utilisateurs peuvent accepter les conditions d’utilisation du Paiement rapide sur iPhone d’Apple sur le Web avant de se connecter au lecteur pour la première fois à l’aide de [liens d’inscription des utilisateurs](https://docs.stripe.com/api/terminal/inscription-lien.md?api-version=2025-07-30.preview). Alternativement, les utilisateurs se verront présenter les conditions générales Paiement rapide sur iPhone d’Apple la première fois qu’ils se associeront 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 d’utilisation du Paiement rapide sur iPhone d’Apple, ils ne sont plus invités à effectuer les connexions suivantes à l’aide du même compte Stripe, y compris sur d’autres appareils mobiles. ![Processus en trois étapes illustrant la connexion d’un identifiant Apple, l’acceptation des conditions et la confirmation de réussite pour le Paiement rapide sur iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png) Link your Apple ID account pour accepter des paiements rapides Tout iPhone peut utiliser jusqu’à trois (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 Paiement rapide 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 les associations du compte, veuillez consulter la section sur les informations liées à Paiement rapide sur iPhone de la [FAQ d’Apple de Paiement rapide 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. Vous pouvez gérer cela de deux manières : - [TapToPayReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPTapToPayReaderDelegate.html) #### Gérer la déconnexion manuellement Votre application doit mettre en œuvre 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. Vous pouvez utiliser ce rappel pour informer l’utilisateur qu’un problème est survenu et que vous avez besoin d’une connexion Internet pour continuer. De plus, vous pouvez également reconnecter manuellement le lecteur lorsque votre application revient 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 `SCPTapToPayReaderDelegate`. Vous devez ensuite passer 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, la trousse 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 la trousse SDK se reconnecte avec succès au lecteur, Stripe vous en informe via `onReaderReconnectSucceeded`. Assurez-vous que votre application annonce que la connexion a été rétablie et que les opérations normales se poursuivent. 1. Si la trousse SDK ne peut pas se reconnecter au lecteur, Stripe vous avertit au moyen de `onReaderReconnectFailed` et `reader:didDisconnect:`. Assurez-vous que votre application annonce 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 } } ``` # Paiement rapide sur Android > This is a Paiement rapide 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. Le Paiement rapide sur Android permet aux utilisateurs d’accepter les paiements sans contact en personne avec des [appareils Android compatibles équipés de la technologie CCP](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices). Le Paiement rapide sur Android nécessite la dernière version de la [trousse SDK Terminal Android](https://stripe.dev/stripe-terminal-android/). Le Paiement rapide sur Android prend en charge les cartes sans contact Visa, Mastercard et American Express ainsi que les portefeuilles numériques NFC (Apple Pay, Google Pay et Samsung Pay). Le Paiement rapide sur Android est une extension de la trousse SDK Terminal Android et permet les paiement directement dans votre application Android. Suivez ces étapes pour connecter votre application au lecteur Paiement rapide sur un appareil Android pris en charge : 1. [Lancer la trousse SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) pour Paiement rapide sur Android. 1. [Découvrir les lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) en utilisant la trousse SDK pour confirmer la compatibilité de l’appareil. 1. [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse SDK pour accepter des paiements. 1. [Gérer les déconnexions inattendues](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) pour vous assurer que votre utilisateur peut continuer à accepter les 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), la trousse SDK renvoie une erreur `TerminalException` fournissant davantage d’informations dans un rappel `onFailure`. ## Initialiser la trousse 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) Paiement rapide sur Android fonctionne selon un processus spécifique 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 la prise en charge matérielle de Paiement rapide sur l’appareil Android. `discoverReaders` vérifie les exigences suivantes concernant l’appareil Android : - Il dispose d’un capteur CCP intégré et fonctionnel et d’un processeur ARM - Fonctionne avec Android 13 ou une version ultérieure - Dispose d’un magasin de clés (keystore) avec prise en charge matérielle pour ECDH (la version [`FEATURE_HARDWARE_KEYSTORE`](https://developer.android.com/reference/android/content/pm/PackageManager#FEATURE_HARDWARE_KEYSTORE) doit être 100 ou supérieure) - Pour la version non simulée du lecteur Paiement rapide, l’application n’est pas déboguable. Votre application *doit* au premier plan pour que le service de lecteur Paiement rapide démarre avec succès. Si votre application s’exécute sur un périphérique qui ne répond pas aux exigences ci-dessus, le rappel `onFailure` revient avec une `TerminalException` qui contient un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) et un contexte supplémentaire. Les échecs à ce stade ne sont pas exploitables par l’utilisateur final. Vous ne pouvez pas utiliser la version de production non simulée du lecteur Paiement rapide avec des applications déboguables ou lorsque les options de développement de l’appareil sont activées. Pour tester votre intégration avec le lecteur Paiement rapide sur Android, définissez `TapToPayDiscoveryConfiguration.isSimulated` sur `true` lors de la détection du lecteur. Vous devez définir cette valeur sur `false` dans la version finale 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 périphérique répond aux exigences matérielles et de système d’exploitation Paiement rapide lors 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 de la trousse SDK Terminal, cette fonction nécessite que votre utilisateur final accepte les demandes d’autorisation pour accéder à l’emplacement et au Bluetooth. Cette fonction prend environ 10 millisecondes pour fonctionner sur la plupart des appareils. ## Me connecter à un lecteur > Dans la version `5.0.0` du SDK Android, vous pouvez utiliser la méthode `easyConnect` pour combiner la découverte du lecteur et la connexion en un seul appel à l’API pour simplifier l’intégration. Consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage) pour en savoir plus. - [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 effectués par Paiement rapide, fournissez le lecteur découvert de l’étape précédente à la méthode `connectReader` `connectReader` vérifie que l’appareil Android répond aux exigences suivantes : - N’est pas débridé et le chargeur de démarrage de l’appareil est verrouillé et inchangé - Une mise à jour de sécurité a été installée au cours des 12 derniers mois - Elle utilise Google Mobile Services et dispose de l’application Google Play Store - Il dispose d’une connexion stable à Internet - Il exécute le système d’exploitation non modifié fourni par le fabricant - L’application utilise le SDK Paiement rapide version 2.20.0 ou ultérieure - Les options pour les développeurs sont désactivées pour la version non simulée du lecteur Paiement rapide Si votre application s’exécute sur un périphérique qui ne répond pas aux exigences ci-dessus, le rappel `onFailure` renvoie une `TerminalException` qui contient un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) et un contexte supplémentaire. L’utilisateur final peut agir sur certaines des [raisons de défaillance](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. Vous devez [enregistrer votre lecteur](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, créez un `TapToPayConnectionConfiguration` et utilisez-le avec le `locationId` défini à l’ID d’emplacement approprié 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 inattendues peuvent se produire entre votre application et le lecteur. Par exemple, le lecteur Paiement rapide peut se déconnecter de manière inattendue, car : - Le système d’exploitation Android met fin au service de lecteur Paiement rapide en raison de contraintes de mémoire. - L’appareil perd la connectivité Internet. Il existe deux manières de gérer cela : #### Tentative de reconnexion automatique Vous pouvez définir `autoReconnectOnUnexpectedDisconnect` sur`true` pour permettre au SDK de tenter automatiquement de se reconnecter lorsqu’une déconnexion inattendue se produit. Le SDK adopte par défaut ce comportement si vous omettez ce paramètre. En option, vous pouvez également mettre en œuvre le champ `TapToPayReaderListener` pour les rappels de reconnexion automatique dans votre application. #### Kotlin ```kotlin val tapToPayReaderListener = yourTapToPayReaderListener val autoReconnectOnUnexpectedDisconnect = true Terminal.getInstance().connectReader( reader, TapToPayConnectionConfiguration( ""{{LOCATION_ID}}"", autoReconnectOnUnexpectedDisconnect, tapToPayReaderListener ), readerCallback, ) ``` Lorsque la trousse SDK tente de se reconnecter automatiquement, les événements suivants se produisent : 1. En cas de déconnexion, la trousse 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 la trousse SDK se reconnecte avec succès au lecteur, Stripe vous en informe via `onReaderReconnectSucceeded`. Assurez-vous que votre application annonce que la connexion a été rétablie et que les opérations normales se poursuivent. 1. Si la trousse SDK ne peut pas se reconnecter au lecteur, Stripe vous avertit au moyen de `onReaderReconnectFailed` et `TapToPayReaderListener.onDisconnect`. Assurez-vous que votre application annonce 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. Mettre en œuvre le champ `TapToPayReaderListener` pour son`onDisconnect` rappel. Cela permet à votre application de se reconnecter au lecteur Paiement rapide et, le cas échéant, d’informer l’utilisateur de ce qui ne va pas et de la manière dont il peut activer l’accès au Paiement rapide. Les utilisateurs finaux peuvent résoudre certaines erreurs, tels 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 entraîner des conflits qui interrompent la session du lecteur. # Paiement rapide sur React Native > This is a Paiement rapide 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. Le Paiement rapide permet aux utilisateurs d’accepter des paiements sans contact en personne avec des [appareils Android compatibles doté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). Le Paiement rapide 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). Le Paiement rapide sur iPhone ou Paiement rapide sur Android est pris en charge dans la trousse SDK native qui permet d’effectuer les paiements directement dans votre application mobile. > Dans la version `0.0.1-bêta.29` de la trousse 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 Paiement rapide sur un appareil pris en charge : - [Initialisez la trousse SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) pour TTPA, si vous utilisez la trousse SDK sur un appareil Android. - [Découvrir les lecteurs](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) en utilisant la trousse SDK pour confirmer la compatibilité de l’appareil. - [Se connecter à un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) avec la trousse SDK pour accepter des paiements. - [Gérer les déconnexions inattendues](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) pour vous assurer que votre utilisateur peut continuer à accepter les paiements si le lecteur se déconnecte de manière inattendue. ## Initialiser la trousse SDK Paiement rapide sur Android fonctionne selon une procédure dédiée pour davantage sécuriser les transactions. Dans cette procédure, une deuxième instance de votre `formulaire d’inscription` est 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 `formulaire d’inscription` en consultant le champ `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 Paiement rapide sur votre appareil. Si votre application s’exécute sur un appareil qui ne répond pas aux exigences ci-dessus, la méthode `discoverReaders` génère 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 ; } ``` ## Me connecter à un lecteur - [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) Pour accepter les paiements effectués par Paiement rapide, fournissez le lecteur découvert 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) à un [emplacement](https://docs.stripe.com/api/terminal/locations.md) lors de la connexion. Pour ce faire, vous devez transmettre l’ID d’emplacement approprié à `connectReader`. Lorsque vous utilisez [les frais de destination avec on_behalf_of](https://docs.stripe.com/terminal/features/connect.md?connect-charge-type=destination) sur les iPhones, vous devez également fournir l’identifiant 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 d’Apple Les conditions générales de la fonctionnalité Paiement rapide sur iPhone d’Apple s’affichent la première fois que vous vous connectez au lecteur. Pour s’enregistrer auprès d’Apple, vous devez indiquer un ID Apple valide, qui sera utilisé pour votre entreprise, puis accepter les conditions énoncées. Vous ne devez effectuer cette opération qu’une seule fois par compte Stripe. Il n’est pas nécessaire de répéter ce processus lors des connexions suivantes, y compris sur d’autres appareils mobiles. Chaque compte connecté doit accepter les conditions lorsque : - Un utilisateur Connect crée des paiements directs - Un utilisateur Connect crée un paiement indirect et précise un compte `on_behalf_of` ![Processus en trois étapes illustrant la connexion d’un identifiant Apple, l’acceptation des conditions et la confirmation de réussite pour le Paiement rapide sur iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png) Link your Apple ID account pour accepter des paiements rapides Tout iPhone peut utiliser jusqu’à trois (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 Paiement rapide 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 les associations du compte, veuillez consulter la section sur les informations liées à Paiement rapide sur iPhone de la [FAQ d’Apple de Paiement rapide 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 Paiement rapide peut se déconnecter de manière inattendue lorsque l’appareil perd la connectivité Internet et lorsque le système d’exploitation Android met fin au service de lecteur Paiement rapide en raison de contraintes de mémoire. Pendant les tests, vous pouvez simuler une déconnexion inattendue en désactivant l’accès Internet à votre appareil. #### Tentative de reconnexion automatique Vous pouvez définir `autoReconnectOnUnexpectedDisconnect` sur`true` pour permettre au SDK de tenter automatiquement de se reconnecter lorsqu’une déconnexion inattendue se produit. Le SDK adopte par défaut ce comportement 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 la trousse SDK tente de se reconnecter automatiquement, les événements suivants se produisent : 1. La trousse SDK vous en informe au moyen de `onDidStartReaderReconnect`. Assurez-vous que votre application signale que la connexion a été perdue et qu’une reconnexion est en cours. - Vous pouvez utiliser la méthode `cancelReaderReconnection` pour arrêter la tentative de reconnexion en tout temps. 1. Si la trousse SDK parvient à se reconnecter au lecteur, Stripe vous en informe au moyen de `onDidSucceedReaderReconnect`. Assurez-vous que votre application signale que la connexion a été restaurée et qu’elle poursuit son fonctionnement normal. 1. Si la trousse SDK ne peut pas se reconnecter au lecteur, Stripe vous avertit au moyen de `onDidFailReaderReconnect` et `onDidDisconnect`. Assurez-vous que votre application signale 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. Mettre en œuvre le rappel `onDidReportUnexpectedReaderDisconnect` . Cela permet à votre application de se reconnecter au lecteur Paiement rapide et, le cas échéant, d’informer l’utilisateur de ce qui ne va pas et de la manière dont il peut activer l’accès au Paiement rapide. Les utilisateurs finaux peuvent résoudre certaines erreurs, tels 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 entraîner des conflits qui interrompent la session du lecteur. ## Prochaines étapes Vous avez associé votre application au lecteur. Vous pouvez maintenant [encaisser votre premier paiement avec Stripe Terminal](https://docs.stripe.com/terminal/payments/collect-card-payment.md). BBPOS et Chipper™ et leur logo sont des marques commerciales ou des marques déposées de BBPOS Limited aux États-Unis ou dans d’autres pays. Verifone® et son logo sont des marques commerciales ou des marques déposées de Verifone aux États-Unis et/ou dans d’autres pays. L’utilisation de ces marques commerciales n’implique en rien une approbation de la part de BBPOS ou de Verifone.