# Développer et tester votre application Apprenez à créer et à tester votre application à l'aide d'un DevKit. Accédez à l’exemple de référentiel d’intégration d’Apps on Devices sur [GitHub](https://github.com/stripe-samples/terminal-apps-on-devices). Utilisez votre appareil DevKit SmartPOS pour tester et itérer votre application sans passer par le processus de déploiement, de révision d’application ou de signature. Si vous avez besoin d’un appareil DevKit, vous pouvez en [commander jusqu’à cinq par utilisateur](https://docs.stripe.com/terminal/fleet/order-and-return-readers.md) dans la section [Lecteurs](https://dashboard.stripe.com/terminal) de votre Dashboard. > #### Prise en charge des lecteurs Verifone > > La prise en charge des lecteurs Verifone est en version bêta publique aux États-Unis et au Canada. Certains lecteurs Verifone sont en version preview privée en Irlande et au Royaume-Uni (V660p, UX700, P630) ainsi qu’à Singapour (V660p, P630). Pour rejoindre la version bêta, vous devez [contacter l’équipe commerciale afin de commander le lecteur concerné](https://stripe.com/contact/sales). ## Configurer le DevKit Avant de pouvoir utiliser votre DevKit pour le développement d’applications, vous devez effectuer les opérations suivantes : 1. Suivez les contrôles à l’écran pour vous connecter à un réseau. 1. [Enregistrez](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=internet#register-reader) l’appareil dans votre compte Stripe. 1. Installez toutes les mises à jour disponibles. Après la configuration initiale, vous pouvez à tout moment enregistrer votre DevKit sur un autre compte ou un autre emplacement. Pour ce faire, connectez le DevKit à Internet et suivez les étapes d’[enregistrement d’un lecteur](https://docs.stripe.com/terminal/payments/connect-reader.md?terminal-sdk-platform=android&reader-type=internet#register-reader). Bien qu’ils soient similaires aux appareils de production, les appareils DevKit : - Ne peut fonctionner que dans les [environnements de test](https://docs.stripe.com/keys.md#test-live-modes). - Sont fournis avec les [options pour les développeurs](https://developer.android.com/studio/debug/dev-options) et [Android Debug Bridge](https://developer.android.com/studio/command-line/adb) (`adb`) activés par défaut. - Affichent un filigrane à l’écran pour indiquer que l’appareil n’est utilisé qu’à des fins de test. Le filigrane se déplace sur l’écran lorsque l’appareil est utilisé pour que toutes les parties de l’écran restent visibles. L’API Terminal prend en charge le ciblage des appareils DevKit enregistrés. ## Développer votre application pour les appareils Stripe Suivez les étapes ci-après pour développer votre application en vue d’une utilisation avec des appareils Android Stripe, y compris la configuration de l’application et le passage à l’application du lecteur Stripe. ## Configurer l'application [Côté client] #### Android Tout d’abord, [configurez votre intégration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=android) pour les paiements en personne. Ensuite, suivez les conseils ci-dessous pour les intégrations Apps on Devices. ### Ajouter des dépendances Ajoutez les dépendances suivantes au script de génération Gradle de votre projet. Les intégrations Apps on Devices nécessitent la version `2.22.0` du [SDK Android Terminal](https://github.com/stripe/stripe-terminal-android) ou une version ultérieure. Nous vous recommandons de procéder à l’intégration avec la [dernière version](https://github.com/stripe/stripe-terminal-android/releases). #### Kotlin ```kotlin dependencies { implementation("com.stripe:stripeterminal-core:5.4.1") implementation("com.stripe:stripeterminal-appsondevices:5.4.1") } ``` Assurez-vous que vous n’utilisez pas d’autres dépendances du SDK Stripe Terminal. Par exemple, si vous avez déjà intégré le SDK Android Terminal, n’utilisez pas la dépendance de niveau supérieur `com.stripe:stripeterminal` (par exemple, `com.stripe:stripeterminal:5.4.1`). Découvrez un exemple d’[inclusion de dépendances dans le script de build de votre application](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/build.gradle.kts#L66). ### Configurer votre application Pour informer le SDK Stripe des événements de cycle de vie, ajoutez un appel [TerminalApplicationDelegate.onCreate()](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal-application-delegate/on-create.html) à la méthode [onCreate()](https://developer.android.com/reference/android/app/Application#onCreate\(\)) de votre sous-classe Application. #### Kotlin ```kotlin class MyApplication : Application() { override fun onCreate() { super.onCreate() TerminalApplicationDelegate.onCreate(this) } } ``` Dans le [manifeste de votre application](https://developer.android.com/guide/topics/manifest/manifest-intro), spécifiez le nom de votre sous-classe `Application` avec l’attribut `android:name`. > Pour vous assurer que votre `Application` prend en charge les appareils fonctionnant sous Android 15, définissez la valeur `targetSdkVersion` sur `24`ou une version ultérieure. ```xml ``` Obtenez plus d’informations sur la [configuration de votre intégration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=android) ou consultez l’exemple de référentiel GitHub d’exemples d’applications Apps on Devices pour obtenir un exemple de [configuration de la sous-classe d’application](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/MyApp.kt#L10). #### React Native Tout d’abord, [configurez votre intégration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=react-native) pour les paiements en personne. Ensuite, suivez les conseils ci-dessous pour les intégrations Apps on Devices. ### Configurer votre application Pour informer le SDK Stripe des événements du cycle de vie, ajoutez un appel `TerminalApplicationDelegate.onCreate()` à la méthode [onCreate()](https://developer.android.com/reference/android/app/Application#onCreate\(\)) de votre sous-classe d’application. #### Kotlin ```kotlin import com.stripeterminalreactnative.TerminalApplicationDelegate class MyApplication : Application() { override fun onCreate() { super.onCreate() TerminalApplicationDelegate.onCreate(this) } } ``` Dans le [manifeste de votre application](https://developer.android.com/guide/topics/manifest/manifest-intro), spécifiez le nom de votre sous-classe `Application` avec l’attribut `android:name`. ```xml ``` Obtenez plus d’informations sur la [configuration de votre intégration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=react-native) ou consultez l’application test sur le référentiel GitHub React Native pour obtenir un exemple de [configuration de la sous-classe d’application](https://github.com/stripe/stripe-terminal-react-native/blob/main/dev-app/android/app/src/main/java/com/dev/app/stripeterminalreactnative/MainApplication.java#L58). ### Initialisation sans serveur Pour les applications sur appareils, vous pouvez utiliser `AppsOnDevicesConnectionTokenProvider` au lieu d’un fournisseur de tokens back-end. Cela permet une initialisation sans qu’un serveur back-end n’ait à fournir de tokens de connexion. ```js import { StripeTerminalProvider, AppsOnDevicesConnectionTokenProvider, } from '@stripe/stripe-terminal-react-native'; function Root() { return ( ); } ``` ## Développer l'application [Côté client] Suivez les conseils ci-dessous pour les intégrations Apps on Devices. ### Détecter un lecteur et s’y connecter #### Android > Dans la version `5.0.0` du SDK Android, vous pouvez utiliser la méthode `easyConnect` pour combiner la détection du lecteur et la connexion en un seul appel à l’API afin de simplifier l’intégration. Pour en savoir plus, consultez le [guide de migration du SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage). Vous devez enregistrer tout nouvel appareil Stripe sur votre compte en tant que nouvel [objet Reader](https://docs.stripe.com/api/terminal/readers/object.md). Utilisez le code d’association fourni dans les paramètres d’administration de l’appareil pour [créer l’objet Reader](https://docs.stripe.com/api/terminal/readers/create.md). Votre application utilise le SDK Android Stripe Terminal pour détecter votre appareil et s’y connecter : Consultez le référentiel d’exemples d’intégration Apps on Devices sur [GitHub](https://github.com/stripe-samples/terminal-apps-on-devices) pour obtenir d’autres exemples de [détection](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/MainViewModel.kt#L90) et de [connexion](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/MainViewModel.kt#L106) à l’aide du mode de transfert. 1. Votre application s’exécute sur votre appareil enregistré. 1. Votre application découvre le lecteur en appelant le paramètre [discoverReaders](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) avec [AppsOnDevicesDiscoveryConfiguration](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-apps-on-devices-discovery-configuration/index.html). 1. Votre application se connecte au lecteur en utilisant [connectReader](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html). L’exemple suivant montre comment détecter un lecteur Stripe et s’y connecter à l’aide du mode transfert dans une application Android : #### Kotlin ```kotlin private fun discoverReaders() { Terminal.getInstance().discoverReaders(config = AppsOnDevicesDiscoveryConfiguration(), discoveryListener = object : DiscoveryListener { override fun onUpdateDiscoveredReaders(readers: List) { // In Apps on Devices discovery, the list will // contain a single reader. Connect to // the reader after it is discovered. readers.firstOrNull()?.let { reader -> connectReader(reader) } } }, callback = object : Callback { override fun onSuccess() { // Handle successfully discovering readers } override fun onFailure(e: TerminalException) { // Handle exception while discovering readers } } ) } private fun connectReader(reader: Reader) { Terminal.getInstance().connectReader( reader,AppsOnDevicesConnectionConfiguration( object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) { // Optionally get notified about reader disconnects (for example, reader was rebooted) } override fun onReportReaderEvent(event: ReaderEvent) { // Optionally get notified about reader events (for example, a card was inserted) } } ), object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successfully connecting to the reader } override fun onFailure(e: TerminalException) { // Handle exception when connecting to the reader } } ) } ``` #### React Native > Dans la version `0.0.1-bêta.29` du SDK React Native, vous pouvez utiliser la méthode [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) pour combiner la découverte du lecteur et la connexion en un seul appel à l’API, afin de simplifier l’intégration. Vous devez enregistrer tout nouvel appareil Stripe sur votre compte en tant que nouvel [objet Reader](https://docs.stripe.com/api/terminal/readers/object.md). Utilisez le code d’association fourni dans les paramètres d’administration de l’appareil pour [créer l’objet Reader](https://docs.stripe.com/api/terminal/readers/create.md). Votre application utilise le SDK React Native Stripe Terminal pour détecter votre appareil et s’y connecter : 1. Votre application s’exécute sur votre appareil enregistré. 1. Votre application découvre le lecteur en appelant le paramètre [discoverReaders](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) avec la [méthode de découverte](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.Android.html#DiscoveryMethod) `AppsOnDevices`. 1. Votre application se connecte au lecteur à l’aide de [connectReader](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1). L’exemple suivant montre comment découvrir et se connecter à un lecteur Stripe en utilisant le mode « Apps on Devices » dans une application React Native : ```js const { discoverReaders, connectReader, discoveredReaders } = useStripeTerminal({ onUpdateDiscoveredReaders: async (readers) => { // After the SDK discovers a reader, your app can connect to it. // The discoverReaders method doesn't resolve until discovery completes, // so use this callback to handle discovered readers. if (readers.length > 0) { const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: readers[0], }); if (error) { console.log('connectReader error:', error); return; } console.log('Reader connected successfully', reader); } }, }); const handleDiscoverReaders = async () => { const { error } = await discoverReaders({ discoveryMethod: 'appsOnDevices', }); if (error) { console.log('discoverReaders error:', error); } }; useEffect(() => { handleDiscoverReaders(); }, [discoverReaders]); ``` ### Encaisser des paiements Après vous être connecté au lecteur en mode transfert, vous pouvez commencer à [encaisser les paiements](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=android#create-payment). L’application Stripe Reader gère l’encaissement des paiements et d’autres opérations de paiement, telles que l’[enregistrement des informations de paiement](https://docs.stripe.com/terminal/features/saving-payment-details/overview.md). Lorsque vous lancez une opération de paiement, l’application Stripe Reader passe au premier plan et se lance en plein écran. Ensuite, elle guide le client tout au long du processus et, une fois l’opération terminée (qu’elle ait abouti ou non) ou annulée par le client, replace votre application au premier plan. Lorsque votre application est au premier plan, l’application de lecteur Stripe continue de s’exécuter en arrière-plan. Obtenez un exemple de [collecte des paiements dans une application Apps on Devices](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/model/CheckoutViewModel.kt#L82). #### Encaisser des paiements en mode hors ligne Apps on Devices prend en charge la [collecte des paiements hors ligne](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md?terminal-sdk-platform=android&reader-type=internet). ## Personnaliser les transitions d’application [Côté client] Lorsqu’une opération de paiement démarre, l’application Stripe Reader passe au premier plan et votre application passe en arrière-plan. Sauf indication contraire, la transition utilise l’animation par défaut du système Android, avec un glissement depuis la droite. Vous pouvez personnaliser la transition en transmettant un paramètre `appTransitionAnimation` à `AppsOnDevicesConnectionConfiguration` lors de la connexion au lecteur. ### Utiliser une animation prédéfinie Le SDK Terminal intègre des animations prédéfinies qui ne nécessitent aucune configuration supplémentaire. Utilisez `AppTransitionAnimation.Preset` avec un `AppTransitionPreset` : #### Kotlin ```kotlin private fun connectReader(reader: Reader) { val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) {} override fun onReportReaderEvent(event: ReaderEvent) {} },appTransitionAnimation = AppTransitionAnimation.Preset(AppTransitionPreset.SLIDE_FROM_BOTTOM) ) Terminal.getInstance().connectReader( reader, config, object : ReaderCallback { override fun onSuccess(reader: Reader) { // Handle successfully connecting to the reader } override fun onFailure(e: TerminalException) { // Handle exception when connecting to the reader } } ) } ``` Si vous utilisez la présélection `SLIDE_FROM_BOTTOM`, l’application Stripe Reader glisse vers le haut depuis le bas de l’écran. ### Utiliser une animation personnalisée Vous pouvez définir des ressources d’animation Android personnalisées dans le répertoire `res/anim/` de votre application. Transmettez ensuite les ID des ressources à `AppTransitionAnimation.Custom`. `enterAnim` contrôle la manière dont l’application Stripe Reader apparaît à l’écran. `exitAnim` contrôle la manière dont votre application quitte l’écran. #### Kotlin ```kotlin val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = object : AppsOnDevicesReaderListener { override fun onDisconnect(reason: DisconnectReason) {} override fun onReportReaderEvent(event: ReaderEvent) {} },appTransitionAnimation = AppTransitionAnimation.Custom( enterAnim = R.anim.slide_in_up, exitAnim = R.anim.slide_out_down ) ) ``` ### Désactiver l’animation de transition Vous pouvez désactiver l’animation de transition en transmettant `AppTransitionAnimation.Custom.NO_ANIMATION` pour les deux paramètres. Pour désactiver l’animation dans une seule direction, transmettez `NO_ANIMATION` pour `enterAnim` ou `exitAnim`. #### Kotlin ```kotlin val config = AppsOnDevicesConnectionConfiguration( appsOnDevicesListener = listener,appTransitionAnimation = AppTransitionAnimation.Custom( enterAnim = AppTransitionAnimation.Custom.NO_ANIMATION, exitAnim = AppTransitionAnimation.Custom.NO_ANIMATION ) ) ``` > Si les ID des ressources d’animation ne sont pas valides, le SDK génère une exception pendant la connexion dans les builds de débogage. Dans les builds de production, le SDK utilise la transition par défaut du système. ## Gestion des appareils [Côté client] Vous pouvez accéder aux paramètres d’administration de l’appareil en lançant l’URI de lien profond `stripe://settings/` depuis votre application. Obtenez un exemple de [lancement de l’URI de lien profond pour accéder aux paramètres d’administration](https://github.com/stripe-samples/terminal-apps-on-devices/blob/718c2de38c7b8003fcf58c536c266bb990ad43a7/app/src/main/java/com/stripe/aod/sampleapp/fragment/HomeFragment.kt#L30). #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")) ) ``` ## Instrumenter l'application [Côté client] Stripe ne fournit pas de solution d’instrumentation au niveau de l’application. Pour garder une trace des crashs et autres logs de votre application, vous pouvez utiliser une bibliothèque tierce telle que Sentry ou Crashlytics. ## Définir la langue de l'appareil [Côté client] La valeur renvoyée par [Locale.getDefault()](https://developer.android.com/reference/java/util/Locale#getDefault\(\)) dépend de la langue choisie par l’utilisateur de l’appareil (et non du pays). Vous pouvez modifier la langue de l’appareil dans les paramètres d’administration. ## Orientation de l'écran [Côté client] Les appareils Android Stripe ont le paramètre *Auto-rotation de l’écran* activé par défaut. Votre application peut remplacer ce paramètre en verrouillant l’interface utilisateur sur une orientation d’écran donnée. Pour ce faire, il suffit de définir l’attribut [screenOrientation](https://developer.android.com/guide/topics/manifest/activity-element#screen) sur les balises `` correspondantes dans le manifeste. ```xml ``` Elle peut également être définie par voie programmatique à l’aide de l’[Activity::setRequestedOrientation](https://developer.android.com/reference/android/app/Activity#setRequestedOrientation\(int\)) dans votre classe `Activity`. #### Kotlin ```kotlin class MainActivity : Activity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Lock to portrait orientation requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT // Or, lock to landscape orientation // requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE } } ``` ## Limites [Côté client] Les appareils Stripe Android n’affichent pas d’interface utilisateur système, de bouton de retour ni de barre d’état. Si votre application doit communiquer un niveau de batterie, un état de charge ou un état de connexion à l’utilisateur, consultez la documentation suivante dédiée à l’API Android pour obtenir des conseils : - [Suivre le niveau et l’état de charge de la batterie](https://developer.android.com/training/monitoring-device-state/battery-monitoring) - [Suivre l’état de la connectivité et des mesures de connexion](https://developer.android.com/training/monitoring-device-state/connectivity-status-type) ## Utiliser les accessoires de l'appareil [Côté client] Lorsque le lecteur Stripe se connecte ou se déconnecte d’une station d’accueil, le système d’exploitation Android déclenche un [changement de configuration](https://developer.android.com/guide/topics/resources/runtime-changes). Par défaut, l’activité de votre application est automatiquement recréée lors d’un changement de configuration. Pour désactiver la recréation automatique de l’activité lors de la connexion ou de la déconnexion d’une station d’accueil, ajoutez `android:configChanges="uiMode"` dans l’entrée `` de votre fichier `AndroidManifest.xml`. ```xml ``` Votre activité peut être notifiée des changements de configuration en implémentant [Activity::onConfigurationChanged](https://developer.android.com/reference/android/app/Activity#onConfigurationChanged\(android.content.res.Configuration\)). Cette méthode n’est appelée que si vous avez spécifié les configurations que vous souhaitez gérer avec l’attribut `android:configChanges` dans votre manifeste. ```kotlin class MainActivity : Activity() { override fun onConfigurationChanged(newConfig: Configuration) { super.onConfigurationChanged(newConfig) // implement custom configuration change handling logic } } ``` ## Tester votre application Utilisez votre appareil S700 DevKit pour tester votre application dans le Dashboard Stripe ou en utilisant Android Debug Bridge (`adb`). #### Android Debug Bridge (adb) Vous pouvez connecter votre appareil DevKit à votre ordinateur à l’aide d’un câble USB-A vers USB-C. Ensuite, utilisez `adb` pour installer directement le fichier APK assemblé de votre application sur l’appareil DevKit. Les exemples suivants partent du principe que le [nom de package](https://developer.android.com/studio/build/configure-app-module) de votre application est `com.example.myapp` et que l’[activité principale](https://developer.android.com/reference/android/content/Intent.html#ACTION_MAIN) est `MainActivity`. ``` $ adb install myapp.apk ``` Une fois l’installation terminée, lancez votre application : ``` $ adb shell am start com.example.myapp/.MainActivity ``` Démarrer les paramètres d’administration : ``` $ adb shell am start -d "stripe://settings/" ``` Si nécessaire, désinstallez votre application : ``` $ adb uninstall com.example.myapp ``` La [documentation sur Android Debug Bridge](https://developer.android.com/studio/command-line/adb) de Google fournit un guide complet sur l’utilisation d’`adb`. #### Dashboard Pour tester votre application dans le Dashboard, procédez comme suit : 1. Dans un environnement de test, ouvrez la page [Lecteurs de terminal](https://dashboard.stripe.com/test/terminal/readers). 1. Si ce n’est pas déjà fait, cliquez sur **Enregistrer un lecteur** pour [enregistrer](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet#register-reader) l’appareil DevKit dans votre compte. 1. Cliquez sur **Terminal** > **Logiciel**. 1. Dans l’onglet [Logiciel](https://dashboard.stripe.com/terminal/software), choisissez l’application que vous souhaitez déployer. Vous pouvez également créer une nouvelle application à déployer. 1. Sur la page des détails de l’application, cliquez sur **Déployer la version**. 1. Choisissez la dernière version de votre application, puis cliquez sur **Suivant**. 1. Choisissez le [groupe de déploiement](https://docs.stripe.com/terminal/features/apps-on-devices/deploy-in-Dashboard.md) pour votre appareil DevKit, puis cliquez sur **Suivant**. 1. Choisissez l’application kiosque de votre choix, puis cliquez sur **Suivant**. Il s’agit de l’application qui se lance par défaut au démarrage du lecteur Stripe. S’il n’y a qu’une seule application à déployer, c’est celle-là que vous devez choisir. 1. Confirmez les détails du déploiement, puis cliquez sur **Déployer**. 1. Redémarrez votre appareil DevKit pour déployer votre application dessus. ### Dépannage Si vous avez précédemment installé votre application par téléchargement indépendant et que vous tentez de la déployer à nouveau, l’erreur suivante risque de se produire : `Failed to apply updates. Code: A9-com.example.posapp`. Vous devez désinstaller manuellement l’application chargée en exécutant la commande suivante : ``` adb uninstall com.example.posapp ``` ## Paiements tests Les appareils DevKit peuvent traiter des paiements tests à l’aide d’une carte de test physique Stripe, que vous pouvez commander dans le [Dashboard](https://dashboard.stripe.com/terminal/shop/thsku_FmpZaTqwezTFvS). Lorsque vous [testez les paiements](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards), vous pouvez utiliser des montants décimaux pour produire des résultats spécifiques. > N’utilisez pas de cartes bancaires réelles pour les paiements tests sur les appareils DevKit. ## Prochaines étapes - [Préparer une application en vue de son examen](https://docs.stripe.com/terminal/features/apps-on-devices/app-review.md) - [Soumettre votre application](https://docs.stripe.com/terminal/features/apps-on-devices/submit.md)