### Pridanie závislosti [#add-dependency]
Na Androide je SDK publikované v Maven Central; v React Native sa inštaluje z npm príkazom
`npx expo install @tapayadot/accept-react-native` a zapojí sa pomocou svojho 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) alebo spustite `npx expo prebuild --clean` (React Native) a potom
vykonajte inicializáciu a autentifikáciu v kóde aplikácie.
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
```
Autentifikujte reláciu obchodníka pomocou tokenu získaného z vášho backendu.
`authenticate` je funkcia typu `suspend` a pri zlyhaní vyhodí výnimku `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]
Skôr ako budú povolené akékoľvek transakcie, obchodník musí dokončiť onboarding KYB. Onboarding už **neriadi
Accept SDK**. Dokončite ho cez Tapaya Platform UI, vlastné UI napojené na Tapaya
API, alebo pomocou odkazu s pozvánkou. Všetky spôsoby nájdete v časti [Onboarding obchodníkov](/merchants/onboarding).
V sandboxe sú obchodníci schválení automaticky hneď po onboardingu, takže nemusíte čakať na posúdenie spracovateľom platieb.
### Overenie pripravenosti obchodníka [#verify-merchant-readiness]
Uistite sa, že obchodník dokončil onboarding a je schválený na prijímanie platieb.
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 pripravený až potom, ako ho schváli spracovateľ platieb. Ak niektoré údaje chýbajú,
onboarding je nutné zopakovať. V niektorých prípadoch môže spracovateľ platieb obchodníka úplne zablokovať, napríklad pri predaji zakázaného tovaru.
### Inštalácia a aktivácia terminálu [#install--activate-terminal]
Platby kartou vyžadujú, aby bol na zariadení nainštalovaný plugin **Tapaya Accept**.
Na kontrolu použite `Accept.plugin.isInstalled()`, a ak plugin chýba, otvorte jeho stránku
v obchode pomocou `Accept.plugin.install()`.
Plugin Tapaya Accept je pre platby kartou nevyhnutný. Skontrolujte, či je nainštalovaný, a potom aktivujte
terminál, prípadne otvorte stránku pluginu v Obchode Play a nainštalujte ho.
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
}
```
### Vytvorenie platobnej transakcie [#create-payment-transaction]
Transakciu vykonáte volaním `Accept.payments.pay()` so sumou (v najmenšej jednotke meny)
a kódom meny podľa ISO 4217. Metóda vracia `Flow`; odoberajte z neho udalosti (collect), aby ste sledovali priebeh a
konečný výsledok. `pay()` nikdy nevyhadzuje výnimku: zlyhania prichádzajú ako `PaymentEvent.CreationFailed`.
Na rýchly štart stačia iba `amount` a `currency`. Všetky voliteľné parametre, napríklad pevné prepitné, úpravy
účtenky alebo metadáta, nájdete v časti [Vytvorenie 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);
}
```