YardPay Pro Android SDK

Kotlin SDK for accepting payments in Android applications with Jetpack Compose components.

Installation

Gradle Dependency

Add the YardPay Pro SDK to your module-level build.gradle.kts:

build.gradle.kts

dependencies {
    implementation("com.quickpay:quickpay-android:1.0.0")
}

Ensure you have the YardPay Pro Maven repository in your project-level settings.gradle.kts:

settings.gradle.kts

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://maven.quickpay.com/releases") }
    }
}

Configuration

Configure the SDK in your Application class or before any payment operations.

MyApplication.kt

import com.quickpay.QuickPay

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        QuickPay.configure(
            context = this,
            publishableKey = "pk_live_your_publishable_key"
        )
    }
}

Hosted Checkout (presentCheckout)

The simplest integration. Opens YardPay's hosted checkout using Custom Tabs for a seamless in-app browser experience.

CheckoutActivity.kt

import com.quickpay.QuickPay
import com.quickpay.model.CheckoutResult

class CheckoutActivity : ComponentActivity() {

    private val checkoutLauncher = registerForCheckoutResult { result ->
        when (result) {
            is CheckoutResult.Completed -> {
                // Payment succeeded
                Log.d("QuickPay", "Payment ID: ${result.paymentId}")
            }
            is CheckoutResult.Cancelled -> {
                // User cancelled
            }
            is CheckoutResult.Failed -> {
                // Payment failed
                Log.e("QuickPay", "Error: ${result.error.message}")
            }
        }
    }

    fun startCheckout(clientSecret: String) {
        QuickPay.presentCheckout(
            activity = this,
            clientSecret = clientSecret,
            launcher = checkoutLauncher
        )
    }
}

QPCardField (Compose)

A Jetpack Compose component for collecting card details within your own UI.

CardInputScreen.kt

import com.quickpay.ui.QPCardField
import com.quickpay.ui.QPCardFieldState
import com.quickpay.ui.rememberQPCardFieldState

@Composable
fun CardInputScreen(clientSecret: String) {
    val cardState = rememberQPCardFieldState()
    var isProcessing by remember { mutableStateOf(false) }

    Column(modifier = Modifier.padding(16.dp)) {
        QPCardField(
            state = cardState,
            modifier = Modifier.fillMaxWidth(),
            style = QPCardFieldStyle(
                textColor = MaterialTheme.colorScheme.onSurface,
                borderColor = MaterialTheme.colorScheme.outline,
                cornerRadius = 8.dp,
                fontSize = 16.sp
            )
        )

        Spacer(modifier = Modifier.height(16.dp))

        Button(
            onClick = { isProcessing = true; confirmPayment(cardState, clientSecret) },
            enabled = cardState.isComplete && !isProcessing,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(if (isProcessing) "Processing..." else "Pay")
        }
    }
}

QPClickToPayButton (Compose)

A Compose component that renders the Click to Pay button and handles SRC authentication.

import com.quickpay.ui.QPClickToPayButton

@Composable
fun PaymentScreen(clientSecret: String) {
    Column(modifier = Modifier.padding(16.dp)) {
        QPClickToPayButton(
            clientSecret = clientSecret,
            modifier = Modifier.fillMaxWidth().height(48.dp),
            onResult = { result ->
                when (result) {
                    is ClickToPayResult.Success -> {
                        // result.token — tokenized card
                        Log.d("QuickPay", "Token: ${result.token.id}")
                    }
                    is ClickToPayResult.Error -> {
                        Log.e("QuickPay", "Error: ${result.error.message}")
                    }
                    is ClickToPayResult.Cancelled -> {
                        // User dismissed
                    }
                }
            }
        )
    }
}

confirmPayment() Coroutine

Submit a payment using collected card details. This is a suspend function that handles 3DS authentication automatically.

PaymentViewModel.kt

import com.quickpay.QuickPay
import com.quickpay.model.PaymentResult
import com.quickpay.model.ConfirmPaymentParams

class PaymentViewModel : ViewModel() {

    fun confirmPayment(cardState: QPCardFieldState, clientSecret: String) {
        viewModelScope.launch {
            val result = QuickPay.confirmPayment(
                params = ConfirmPaymentParams(
                    clientSecret = clientSecret,
                    cardDetails = cardState.cardDetails,
                    returnUrl = "myapp://payment-complete"
                )
            )

            when (result) {
                is PaymentResult.Succeeded -> {
                    _uiState.value = UiState.Success(result.paymentId)
                }
                is PaymentResult.RequiresAction -> {
                    // 3DS is handled automatically
                    _uiState.value = UiState.Awaiting3DS
                }
                is PaymentResult.Failed -> {
                    _uiState.value = UiState.Error(result.error.message)
                }
            }
        }
    }
}

Subscription Portal

Open the customer portal where users can manage subscriptions, update payment methods, and view billing history.

import com.quickpay.QuickPay
import com.quickpay.model.PortalResult

class AccountActivity : ComponentActivity() {

    private val portalLauncher = registerForPortalResult { result ->
        when (result) {
            is PortalResult.PaymentMethodUpdated -> {
                // Refresh UI
            }
            is PortalResult.SubscriptionCancelled -> {
                Log.d("QuickPay", "Cancelled: ${result.subscriptionId}")
            }
            is PortalResult.Dismissed -> {
                // User closed the portal
            }
        }
    }

    fun openPortal(portalSessionUrl: String) {
        QuickPay.presentPortal(
            activity = this,
            url = portalSessionUrl,
            launcher = portalLauncher
        )
    }
}

Requirements

Android API 24+ (Android 7.0)
Kotlin 1.8+
Jetpack Compose 1.4+ (for Compose components)
AndroidX Browser library (for Custom Tabs)