### Abhängigkeit hinzufügen [#add-dependency]
Für Android wird das SDK über Maven Central veröffentlicht; unter React Native wird es mit
`npx expo install @tapayadot/accept-react-native` aus npm installiert und über sein Config-Plugin eingebunden.
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"]
}
}
```
Synchronisieren Sie das Projekt (Android) oder führen Sie `npx expo prebuild --clean` aus (React Native). Initialisieren und
authentifizieren Sie das SDK anschließend in Ihrem Anwendungscode.
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
```
Authentifizieren Sie eine Händler-Session mit einem Token, das Sie von Ihrem Backend erhalten.
`authenticate` ist eine `suspend`-Funktion und wirft bei einem Fehler eine `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 des Händlers [#onboard-the-merchant]
Bevor Transaktionen zugelassen werden, muss der Händler das KYB-Onboarding abschließen. Das Onboarding wird **nicht mehr
über das Accept SDK gesteuert**. Schließen Sie es über das Tapaya Platform UI, Ihre eigene Oberfläche auf Basis der Tapaya
API oder einen Einladungslink ab. Alle Methoden finden Sie unter [Händler-Onboarding](/merchants/onboarding).
In der Sandbox-Umgebung werden Händler direkt nach dem Onboarding automatisch genehmigt, sodass Sie nicht auf die Prüfung durch den Zahlungsabwickler warten müssen.
### Bereitschaft des Händlers prüfen [#verify-merchant-readiness]
Stellen Sie sicher, dass der Händler das Onboarding abgeschlossen hat und für die Zahlungsannahme genehmigt ist.
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';
```
Der Händler ist erst bereit, nachdem der Zahlungsabwickler ihn genehmigt hat. Fehlen Angaben,
muss das Onboarding wiederholt werden. In manchen Fällen kann der Zahlungsabwickler den Händler vollständig sperren, etwa beim Verkauf verbotener Waren.
### Terminal installieren und aktivieren [#install--activate-terminal]
Für Kartenzahlungen muss das Plugin **Tapaya Accept** auf dem Gerät installiert sein.
Prüfen Sie dies mit `Accept.plugin.isInstalled()` und öffnen Sie mit `Accept.plugin.install()` den Store-Eintrag,
falls es fehlt.
Das Plugin Tapaya Accept ist für Kartenzahlungen erforderlich. Prüfen Sie, ob es installiert ist, und aktivieren Sie dann
das Terminal, oder öffnen Sie den Eintrag im Play Store, um es zu installieren.
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
}
```
### Zahlungstransaktion erstellen [#create-payment-transaction]
Um eine Transaktion durchzuführen, rufen Sie `Accept.payments.pay()` mit dem Betrag (in der kleinsten Einheit der Währung)
und einem Währungscode nach ISO 4217 auf. Die Methode gibt einen `Flow` zurück; sammeln Sie ihn ein (collect), um den Fortschritt und
das endgültige Ergebnis zu verfolgen. `pay()` wirft nie eine Exception: Fehler kommen als `PaymentEvent.CreationFailed` an.
Für den Schnellstart genügen `amount` und `currency`. Alle optionalen Parameter, etwa ein festes Trinkgeld, Anpassungen
am Beleg oder Metadaten, finden Sie unter [Zahlung erstellen](../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);
}
```