# 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 > > Les Verifone P630 et UX700 sont **généralement disponibles** aux États-Unis. Les Verifone V660p et M425 sont en **version bêta publique** pour les États-Unis et le Canada, et les P630 et UX700 sont également en **version bêta publique** pour le Canada, la Belgique, l’Italie, les Pays-Bas, la Norvège, l’Espagne et la Suède. Les V660p, UX700 et P630 sont en **version bêta privée** pour l’Irlande et le Royaume-Uni, la France, Singapour (V660p, P630) et l’Australie. > > Pour commander un lecteur Verifone ou rejoindre une version bêta, vous devez [contacter l’équipe commerciale](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. 2. [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. 3. 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.7.0") implementation("com.stripe:stripeterminal-appsondevices:5.7.0") } ``` 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.7.0`). 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é. 2. 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). 3. 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é. 2. 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`. 3. 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. > Les animations de transition personnalisées nécessitent la version 2.42 ou ultérieure du logiciel du lecteur. #### Android 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. #### React Native Vous pouvez personnaliser la transition en transmettant un paramètre `appTransitionAnimation` à `ConnectAppsOnDevicesParams` ou `EasyConnectAppsOnDevicesParams` lors de la connexion au lecteur. ### Utiliser une animation prédéfinie Le SDK inclut une animation prédéfinie qui ne nécessite aucune configuration supplémentaire. Transmettez `{ type: ’preset’, preset: AppTransitionPreset.SlideFromBottom }` : ```typescript import { useStripeTerminal, AppTransitionPreset, } from '@stripe/stripe-terminal-react-native'; const { connectReader } = useStripeTerminal(); const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'preset', preset: AppTransitionPreset.SlideFromBottom }, }); ``` Si vous utilisez la présélection `SlideFromBottom`, 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 Android. Ensuite, transmettez les ID de ressource en tant que `enterAnim` et `exitAnim`. Le paramètre `enterAnim` contrôle la manière dont l’application Stripe Reader apparaît à l’écran. Le paramètre `exitAnim` contrôle la manière dont votre application disparaît de l’écran. ```typescript // enterAnim and exitAnim are Android resource IDs (numbers) from your res/anim/ directory const enterAnim: number = /* your enter animation resource ID */; const exitAnim: number = /* your exit animation resource ID */; const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'custom', enterAnim, exitAnim }, }); ``` ### Désactiver l’animation de transition Vous pouvez désactiver l’animation de transition en transmettant `0` à la fois pour `enterAnim` et `exitAnim`. Pour désactiver l’animation dans une seule direction, transmettez `0` pour `enterAnim` ou `exitAnim`. ```typescript const { reader, error } = await connectReader({ discoveryMethod: 'appsOnDevices', reader: selectedReader, appTransitionAnimation: { type: 'custom', enterAnim: 0, exitAnim: 0 }, }); ``` > 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. ### Utilisez l’animation système par défaut Omettez `appTransitionAnimation` ou transmettez `{ type: ’systemDefault’ }` pour utiliser la transition système par défaut d’Android. ### Personnaliser les transitions lors de l’ouverture des paramètres de l’appareil Votre application peut ouvrir l’[écran des paramètres](https://docs.stripe.com/terminal/payments/setup-reader/stripe-reader-s700-s710.md#settings) du lecteur pour permettre aux entreprises de configurer le Wi-Fi, de rechercher des mises à jour logicielles ou d’ajuster les préférences de l’appareil. Cela utilise le lien profond `stripe://settings/`, qui déclenche une transition d’activité Android standard. Le paramètre `appTransitionAnimation` configuré lors de la [connexion du lecteur](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#customize-transitions) ne s’applique pas à ces transitions. Il contrôle uniquement les animations déclenchées par le SDK lors des opérations de paiement. Pour créer une transition cohérente lors de la navigation vers les paramètres de l’appareil, utilisez `ActivityOptions.makeCustomAnimation` avec les préréglages d’animation intégrés au SDK. Le SDK Terminal inclut des fichiers de ressources d’animation pour chaque préréglage. Vous pouvez accéder aux ID de ressources d’animation d’entrée et de sortie depuis `AppTransitionPreset.SLIDE_FROM_BOTTOM` à l’aide de `.enterAnim` et `.exitAnim`. Actuellement, `SLIDE_FROM_BOTTOM` est le seul préréglage disponible : #### Kotlin ```kotlin import android.app.ActivityOptions import com.stripe.stripeterminal.appsondevices.extensions.enterAnim import com.stripe.stripeterminal.appsondevices.extensions.exitAnim import com.stripe.stripeterminal.external.models.AppTransitionPreset val options = ActivityOptions.makeCustomAnimation( this, AppTransitionPreset.SLIDE_FROM_BOTTOM.enterAnim, AppTransitionPreset.SLIDE_FROM_BOTTOM.exitAnim, ) startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")), options.toBundle() ) ``` Pour désactiver l’animation, transmettez `0` pour les deux paramètres d’animation : #### Kotlin ```kotlin val options = ActivityOptions.makeCustomAnimation(this, 0, 0) startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/")), options.toBundle() ) ``` ## Gestion des appareils [Côté client] Votre application peut intégrer des liens profonds redirigeant directement vers des écrans spécifiques des paramètres de l’appareil, ce qui permet aux utilisateurs d’accéder à la configuration exacte dont ils ont besoin sans avoir à parcourir l’ensemble du menu administrateur. Par exemple, ajoutez un bouton « Paramètres WiFi » qui ouvre la configuration du réseau, ou permettez au personnel d’ajuster la luminosité de l’écran sans avoir à naviguer dans le menu principal des paramètres. ### Liens profonds disponibles Lancez l’une de ces URI à l’aide d’une intention Android `ACTION_VIEW` : | Destination | URI | Code PIN administrateur obligatoire | | --- | --- | --- | | Tous les paramètres | `stripe://settings/` | Toujours | | Réseau | `stripe://settings/network/` | Toujours | | Avancé | `stripe://settings/advanced/` | Toujours | | Code d’inscription | `stripe://settings/registration_code/` | Toujours | | Apparence | `stripe://settings/appearance/` | Contournable | | Langue | `stripe://settings/language/` | Contournable | | Rapport de bug | `stripe://settings/bug_report/` | Contournable | Les écrans marqués **Contournable** demandent le code PIN administrateur par défaut, mais votre application peut ignorer l’invite. Consultez la section [Contourner le code PIN administrateur](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#bypass-the-admin-pin) ci-dessous. - **Réseau** permet aux utilisateurs de sélectionner et de configurer les réseaux WiFi, y compris l’adresse IP statique et les paramètres DNS personnalisés. - **Avancé** permet d’accéder à des paramètres supplémentaires tels que les [diagnostics](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md#diagnostics) et la restauration des paramètres d’usine. - **Code d’inscription** génère un code d’association pour [inscrire le lecteur](https://docs.stripe.com/terminal/fleet/register-readers.md#smart-readers) à un compte Stripe. - **Apparence** contrôle la luminosité de l’écran et le thème. - **Rapport de bug** recueille les logs de l’appareil et les informations de diagnostic, et les envoie au service de support Stripe à des fins de dépannage. - **Langue** contrôle la langue d’affichage du lecteur. ### Lancer un écran de paramètres Utilisez une intention Android `ACTION_VIEW` standard pour ouvrir un écran de paramètres. Pour personnaliser l’animation de transition, transmettez un bundle `ActivityOptions` comme décrit dans la section [Personnaliser les transitions lors de l’ouverture des paramètres de l’appareil](https://docs.stripe.com/terminal/features/apps-on-devices/build.md#customize-transitions-when-opening-device-settings). Consultez l’[application exemple Apps on Devices](https://github.com/stripe-samples/terminal-apps-on-devices) pour découvrir un exemple concret complet. #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/network/")) ) ``` ### Contourner le code PIN administrateur Pour les écrans Apparence, Langue et Rapport de bug, l’appareil demande le code PIN administrateur par défaut. Vous pouvez ignorer cette invite en ajoutant l’extra `bypass_admin_menu_passcode` à l’intention. Cela s’avère utile pour les écrans à faible risque pour lesquels il n’est pas nécessaire que le personnel saisisse un code PIN à chaque fois. #### Kotlin ```kotlin startActivity( Intent(Intent.ACTION_VIEW) .setData(Uri.parse("stripe://settings/appearance/")) .putExtra("bypass_admin_menu_passcode", true) ) ``` > Ne contournez le code PIN administrateur que pour les écrans non sensibles. Tous les écrans des paramètres, du réseau, avancés et du code d’inscription requièrent systématiquement le code PIN, indépendamment de cet indicateur. ## 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 le niveau de batterie, l’état de charge et l’état de la connexion à vos utilisateurs, vous pouvez consulter la documentation API Android suivante 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. > #### Comportement post-transaction > > Lorsque vous installez votre application personnalisée directement, vous ne pouvez pas définir l’application kiosque préférée du DevKit. Une fois une transaction terminée, le DevKit revient toujours à l’application Stripe reader par défaut. Si vous souhaitez que votre application devienne l’application kiosque préférée sur un DevKit, vous devez utiliser un groupe de déploiement comme indiqué dans les instructions du Dashboard. 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). 2. 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. 3. Cliquez sur **Terminal** > **Logiciel**. 4. 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. 5. Sur la page des détails de l’application, cliquez sur **Déployer la version**. 6. Choisissez la dernière version de votre application, puis cliquez sur **Suivant**. 7. 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**. 8. Choisissez votre application kiosque préférée, puis cliquez sur **Suivant**. Le lecteur Stripe lance cette application au démarrage et après chaque transaction. S’il n’y a qu’une seule application à déployer, sélectionnez-la. 9. Confirmez les détails du déploiement, puis cliquez sur **Déployer**. 10. 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)