### Ajouter la dépendance [#add-dependency]
Sur Android, le SDK est publié sur Maven Central ; sur React Native, il s’installe depuis npm avec
`npx expo install @tapayadot/accept-react-native` et est configuré par son plugin de configuration.
Android (Kotlin)
React Native (TypeScript)
```kotlin title="build.gradle.kts"
dependencies {
// [!code ++:1]
implementation("com.tapaya:accept:1.15.0")
}
```
```json title="app.json"
{
"expo": {
"plugins": ["@tapayadot/accept-react-native"]
}
}
```
Synchronisez le projet (Android) ou exécutez `npx expo prebuild --clean` (React Native), puis initialisez le SDK et
authentifiez-vous dans le code de votre application.
Android (Kotlin)
React Native (TypeScript)
```kotlin title="MyApplication.kt"
// Step 1: Initialize (once, in Application.onCreate)
Accept.initialize(this) // sandbox by default; pass isProduction = true to go live
```
```typescript title="App.tsx"
import Accept from '@tapayadot/accept-react-native';
// Step 1: Initialize (once, at app startup)
Accept.initialize(); // sandbox by default; pass { isProduction: true } to go live
```
Authentifiez une session commerçant avec un jeton obtenu depuis votre backend.
`authenticate` est une fonction `suspend` qui lève une `AcceptException` en cas d’échec.
Android (Kotlin)
React Native (TypeScript)
```kotlin
// Step 2: Authenticate (suspend; call from a coroutine)
try {
val sdkToken = myBackend.login() // token from POST /merchant/auth/login
Accept.auth.authenticate(sdkToken)
// Accept.state now emits SdkState.Authenticated
} catch (e: AcceptException) {
// handle authentication failure
}
```
```typescript
// Step 2: Authenticate
try {
const sdkToken = await myBackend.login(); // token from POST /merchant/auth/login
await Accept.auth.authenticate(sdkToken);
// Accept.state is now 'authenticated'
} catch (error) {
// handle authentication failure
}
```
### Effectuer l’onboarding du commerçant [#onboard-the-merchant]
Avant de pouvoir effectuer la moindre transaction, le commerçant doit terminer l’onboarding KYB. L’onboarding n’est **plus
piloté par l’Accept SDK**. Effectuez-le via la Tapaya Platform UI, votre propre interface s’appuyant sur l’API
Tapaya, ou un lien d’invitation. Consultez [Onboarding des commerçants](/merchants/onboarding) pour toutes les méthodes.
Dans l’environnement sandbox, les commerçants sont automatiquement approuvés juste après l’onboarding : vous n’avez donc pas à attendre l’examen du processeur de paiement.
### Vérifier que le commerçant est prêt [#verify-merchant-readiness]
Assurez-vous que le commerçant a terminé l’onboarding et qu’il est approuvé pour accepter des paiements.
Android (Kotlin)
React Native (TypeScript)
```kotlin
val ready = when (val status = Accept.merchant.onboardingStatus()) {
OnboardingStatus.ReadyForPayments -> true
is OnboardingStatus.RequiresAction -> false // status.state describes what's blocking
}
```
```typescript
const status = await Accept.merchant.onboardingStatus();
// status.state describes what's blocking when it requires action
const ready = status.type === 'readyForPayments';
```
Le commerçant n’est prêt qu’une fois approuvé par le processeur de paiement. S’il manque des informations,
l’onboarding doit être recommencé. Dans certains cas, le processeur de paiement peut bloquer complètement le commerçant, par exemple s’il vend des produits interdits.
### Installer et activer le terminal [#install--activate-terminal]
Les paiements par carte nécessitent que le plugin **Tapaya Accept** soit installé sur l’appareil.
Utilisez `Accept.plugin.isInstalled()` pour le vérifier, et `Accept.plugin.install()` pour ouvrir sa fiche
dans le store s’il est absent.
Le plugin Tapaya Accept est requis pour les paiements par carte. Vérifiez s’il est installé, puis activez
le terminal, ou ouvrez sa fiche sur le Play Store pour l’installer.
Android (Kotlin)
React Native (TypeScript)
```kotlin
if (Accept.plugin.isInstalled()) {
// suspend; returns ActivateTerminalResult (Success / Canceled / Failed)
Accept.plugin.activateTerminal()
} else {
Accept.plugin.install() // opens the store listing
}
```
```typescript
if (Accept.plugin.isInstalled()) {
// returns ActivateTerminalResult: { type: 'success' | 'canceled' | 'failed' }
await Accept.plugin.activateTerminal();
} else {
await Accept.plugin.install(); // opens the store listing
}
```
### Créer une transaction de paiement [#create-payment-transaction]
Pour exécuter une transaction, appelez `Accept.payments.pay()` avec le montant (dans la plus petite unité de la devise)
et un code de devise ISO 4217. La méthode renvoie un `Flow` ; collectez-le pour suivre la progression et
le résultat final. `pay()` ne lève jamais d’exception : les échecs arrivent sous forme de `PaymentEvent.CreationFailed`.
Le démarrage rapide ne nécessite que `amount` et `currency`. Pour tous les paramètres facultatifs, comme un pourboire fixe, la personnalisation
du reçu ou les métadonnées, consultez [Créer un paiement](../integration/card_terminal#create-a-payment).
Android (Kotlin)
React Native (TypeScript)
```kotlin
Accept.payments.pay(amount = 15000, currency = "CZK") // 150.00 Kč
.collect { event ->
when (event) {
PaymentEvent.Creating -> Log.d("pay", "creating")
is PaymentEvent.Created -> Log.d("pay", "created ${event.paymentToken}")
PaymentEvent.Launched -> Log.d("pay", "launched")
is PaymentEvent.Result -> Log.d("pay", event.payResult.toString())
is PaymentEvent.CreationFailed -> Log.e("pay", event.cause.toString())
}
}
```
```typescript
// payAsync() reduces the event stream to its outcome; use pay() to render progress
const result = await Accept.payments.payAsync({
amount: 15000,
currency: 'CZK', // 150.00 Kč
});
if (result.type === 'success') {
console.log(result.paymentToken, result.receiptUrl);
}
```