### Přidání závislosti [#add-dependency]
Na Androidu je SDK publikováno v Maven Central; v React Native se instaluje z npm příkazem
`npx expo install @tapayadot/accept-react-native` a zapojí se pomocí svého konfiguračního pluginu.
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"]
}
}
```
Synchronizujte projekt (Android) nebo spusťte `npx expo prebuild --clean` (React Native) a poté
proveďte inicializaci a autentizaci v kódu aplikace.
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
```
Autentizujte relaci obchodníka pomocí tokenu získaného z vašeho backendu.
`authenticate` je funkce typu `suspend` a při selhání vyhodí výjimku `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 obchodníka [#onboard-the-merchant]
Než budou povoleny jakékoli transakce, musí obchodník dokončit onboarding KYB. Onboarding už **neřídí
Accept SDK**. Dokončete jej přes Tapaya Platform UI, vlastní UI napojené na Tapaya
API, nebo pomocí odkazu s pozvánkou. Všechny způsoby najdete v části [Onboarding obchodníků](/merchants/onboarding).
V sandboxu jsou obchodníci schváleni automaticky hned po onboardingu, takže nemusíte čekat na posouzení zpracovatelem plateb.
### Ověření připravenosti obchodníka [#verify-merchant-readiness]
Ujistěte se, že obchodník dokončil onboarding a je schválen pro přijímání plateb.
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';
```
Obchodník je připraven až poté, co jej schválí zpracovatel plateb. Pokud některé údaje chybí,
je nutné onboarding zopakovat. V některých případech může zpracovatel plateb obchodníka úplně zablokovat, například při prodeji zakázaného zboží.
### Instalace a aktivace terminálu [#install--activate-terminal]
Platby kartou vyžadují, aby byl na zařízení nainstalován plugin **Tapaya Accept**.
Ke kontrole použijte `Accept.plugin.isInstalled()`, a pokud plugin chybí, otevřete jeho stránku
v obchodě pomocí `Accept.plugin.install()`.
Plugin Tapaya Accept je pro platby kartou nezbytný. Zkontrolujte, zda je nainstalován, a poté aktivujte
terminál, případně otevřete stránku pluginu v Obchodě Play a nainstalujte jej.
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
}
```
### Vytvoření platební transakce [#create-payment-transaction]
Transakci provedete voláním `Accept.payments.pay()` s částkou (v nejmenší jednotce měny)
a kódem měny podle ISO 4217. Metoda vrací `Flow`; odebírejte z něj události (collect), abyste sledovali průběh a
konečný výsledek. `pay()` nikdy nevyhazuje výjimku: selhání přicházejí jako `PaymentEvent.CreationFailed`.
Pro rychlý start stačí pouze `amount` a `currency`. Všechny volitelné parametry, například pevné spropitné, úpravy
účtenky nebo metadata, najdete v části [Vytvoření platby](../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);
}
```