### Aggiungere la dipendenza [#add-dependency]
Su Android l'SDK è pubblicato su Maven Central; su React Native si installa da npm con
`npx expo install @tapayadot/accept-react-native` e viene collegato dal suo config plugin.
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"]
}
}
```
Sincronizzi il progetto (Android) o esegua `npx expo prebuild --clean` (React Native), quindi inizializzi l'SDK ed esegua
l'autenticazione nel codice dell'applicazione.
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
```
Autentichi una sessione dell'esercente con un token ottenuto dal Suo backend.
`authenticate` è una funzione `suspend` e in caso di errore genera un'`AcceptException`.
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
}
```
### Onboarding dell'esercente [#onboard-the-merchant]
Prima che qualsiasi transazione sia consentita, l'esercente deve completare l'onboarding KYB. L'onboarding **non è più
gestito dall'Accept SDK**. Lo completi tramite la Tapaya Platform UI, una Sua interfaccia basata sulla Tapaya
API o un link di invito. Tutti i metodi sono descritti in [Onboarding degli esercenti](/merchants/onboarding).
Nell'ambiente sandbox gli esercenti vengono approvati automaticamente subito dopo l'onboarding, quindi non deve attendere la verifica del processore di pagamento.
### Verificare che l'esercente sia pronto [#verify-merchant-readiness]
Si assicuri che l'esercente abbia completato l'onboarding e sia approvato per accettare pagamenti.
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';
```
L'esercente è pronto solo dopo l'approvazione del processore di pagamento. Se mancano alcune informazioni,
l'onboarding deve essere ripetuto. In alcuni casi il processore di pagamento potrebbe bloccare completamente l'esercente, ad esempio se vende merci vietate.
### Installare e attivare il terminale [#install--activate-terminal]
I pagamenti con carta richiedono che sul dispositivo sia installato il plugin **Tapaya Accept**.
Usi `Accept.plugin.isInstalled()` per verificarlo e `Accept.plugin.install()` per aprire la scheda
nello store se manca.
Il plugin Tapaya Accept è obbligatorio per i pagamenti con carta. Verifichi se è installato, quindi attivi
il terminale, oppure apra la scheda nel Play Store per installarlo.
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
}
```
### Creare una transazione di pagamento [#create-payment-transaction]
Per eseguire una transazione, chiami `Accept.payments.pay()` con l'importo (nell'unità minima della valuta)
e un codice valuta ISO 4217. Restituisce un `Flow`; lo raccolga per seguire l'avanzamento e
l'esito finale. `pay()` non genera mai eccezioni: gli errori arrivano come `PaymentEvent.CreationFailed`.
La guida rapida richiede solo `amount` e `currency`. Per tutti i parametri facoltativi, come una mancia fissa, le personalizzazioni
della ricevuta o i metadati, consulti [Creare un pagamento](../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);
}
```