Android Native SDK

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        // Peach SDK + Gradle plugin
        maven { url = uri("https://gitlab.com/api/v4/projects/81506485/packages/maven") }
        maven { url = uri("https://maven.juspay.in/hyper-sdk/") }  // transitive scan-card deps
        maven { url = uri("https://jitpack.io") }
    }
}

maven { url "https://gitlab.com/api/v4/projects/81506485/packages/maven" }

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

android {
    compileSdk = 36

    defaultConfig {
        minSdk = 24
        targetSdk = 36
    }

    // Enable Java 8 features
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

dependencies {
    // Peach Orchestration SDK - note the io.peachpayments group.
    // The artifact name is unchanged; only the group moved.
    //
    // This is the ONLY Peach artifact you declare. It pulls in
    // io.peachpayments:hyperswitch-sdk-android-api (1.1.2),
    // -logger (1.0.4), and the sentry_react-native,
    // react-native-inappbrowser-reborn and react-native-svg
    // artifacts (1.0.1) transitively - don't list those yourself.
    implementation("io.peachpayments:hyperswitch-sdk-android:1.5.5")
}

import io.peachpayments.PaymentSession
import io.peachpayments.paymentsheet.PaymentSheet
import io.peachpayments.paymentsheet.PaymentSheetResult

class CheckoutActivity : AppCompatActivity() {

    private lateinit var paymentSession: PaymentSession

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Create a PaymentSession with your publishable key
        paymentSession = PaymentSession.Builder(this, "pk_test_your_publishable_key")
            .customBackendUrl("https://app.sandbox-next.peachpayments.com/api")
            .build()
    }
}

<application android:name=".MyApplication" ...>

PaymentConfiguration.init(applicationContext, "pk_test_your_publishable_key")

android {
    buildTypes {
        debug {
            buildConfigField("String", "HYPERSWITCH_KEY", "\"pk_test_xxx\"")
            buildConfigField("String", "HYPERSWITCH_API_URL", "\"https://app.sandbox-next.peachpayments.com/api\"")
        }
        release {
            buildConfigField("String", "HYPERSWITCH_KEY", "\"pk_live_xxx\"")
            buildConfigField("String", "HYPERSWITCH_API_URL", "\"https://app.next.peachpayments.com/api\"")
        }
    }
}

paymentSession = PaymentSession.Builder(this, BuildConfig.HYPERSWITCH_KEY)
    .customBackendUrl(BuildConfig.HYPERSWITCH_API_URL)
    .build()

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import io.peachpayments.PaymentSession
import io.peachpayments.paymentsheet.PaymentSheet
import io.peachpayments.paymentsheet.PaymentSheetResult
import kotlinx.coroutines.launch

class CheckoutActivity : AppCompatActivity() {

    private lateinit var paymentSession: PaymentSession

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_checkout)

        // Step 1: Create PaymentSession with publishable key
        paymentSession = PaymentSession.Builder(this, "pk_test_your_publishable_key")
            .customBackendUrl("https://app.sandbox-next.peachpayments.com/api")
            .build()

        // Step 2: Set up pay button
        findViewById<Button>(R.id.payButton).setOnClickListener {
            startCheckout()
        }
    }

    // Step 3: Start checkout flow
    private fun startCheckout() {
        lifecycleScope.launch {
            try {
                showLoading(true)

                // Create payment intent on your server
                val checkoutData = createPaymentIntent()

                // Initialise and present payment sheet
                presentPaymentSheet(checkoutData)

            } catch (e: Exception) {
                showLoading(false)
                showError(e.message ?: "Unknown error")
            }
        }
    }

    // Step 4: Create Payment Intent (call your server)
    private suspend fun createPaymentIntent(): CheckoutData {
        val response = RetrofitClient.api.createPaymentIntent(
            CreatePaymentRequest(
                amount = 6500,
                currency = "zar"
            )
        )
        return CheckoutData(
            clientSecret = response.clientSecret,
            customerId = response.customerId,
            ephemeralKey = response.ephemeralKey
        )
    }

    // Step 5: Initialise and Present Payment Sheet
    private fun presentPaymentSheet(data: CheckoutData) {
        // Initialise the payment session with client secret
        paymentSession.initPaymentSession(data.clientSecret)

        showLoading(false)

        // Present the payment sheet
        paymentSession.presentPaymentSheet { result ->
            handlePaymentResult(result)
        }
    }

    // Step 6: Handle payment result
    private fun handlePaymentResult(result: PaymentSheetResult) {
        when (result) {
            is PaymentSheetResult.Completed -> {
                // Payment succeeded
                showSuccess("Payment successful!")
                finish()
            }
            is PaymentSheetResult.Canceled -> {
                // User canceled - do nothing
                Log.d("Checkout", "Payment canceled")
            }
            is PaymentSheetResult.Failed -> {
                // Payment failed
                showError(result.error.localizedMessage ?: "Payment failed")
            }
        }
    }

    // Helper methods
    private fun showLoading(show: Boolean) {
        findViewById<ProgressBar>(R.id.progressBar).visibility =
            if (show) View.VISIBLE else View.GONE
        findViewById<Button>(R.id.payButton).isEnabled = !show
    }

    private fun showSuccess(message: String) {
        Toast.makeText(this, message, Toast.LENGTH_LONG).show()
    }

    private fun showError(message: String) {
        AlertDialog.Builder(this)
            .setTitle("Error")
            .setMessage(message)
            .setPositiveButton("OK", null)
            .show()
    }
}

data class CheckoutData(
    val clientSecret: String,
    val customerId: String? = null,
    val ephemeralKey: String? = null
)

data class CreatePaymentRequest(
    val amount: Int,
    val currency: String
)

val configuration = PaymentSheet.Configuration(
    merchantDisplayName = "Your Store",
    googlePay = PaymentSheet.GooglePayConfiguration(
        environment = PaymentSheet.GooglePayConfiguration.Environment.Test,
        // Use .Production for live
        countryCode = "ZA",
        currencyCode = "ZAR",
        merchantName = "Your Store"  // Shown in Google Pay sheet
    )
)

<io.peachpayments.view.BasePaymentWidget
    android:id="@+id/googlePayButton"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:paymentMethod="google_pay" />

PaymentConfiguration.init(applicationContext, "pk_test_your_publishable_key")

val launcher = UnifiedPaymentLauncher.createGooglePayLauncher(
    activity = this,
    readyCallback = { isReady ->
        // Treat this as the signal that the button is usable
        googlePayButton.isVisible = isReady
    },
    resultCallback = { result ->
        // Handle completed / canceled / failed
    }
)

<activity android:name=".CheckoutActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="yourapp" android:host="payment-return" />
    </intent-filter>
</activity>

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    intent?.data?.let { uri ->
        if (uri.scheme == "yourapp" && uri.host == "payment-return") {
            // Payment flow completed, check status
            checkPaymentStatus()
        }
    }
}

val configuration = PaymentSheet.Configuration(
    merchantDisplayName = "Your Store",
    paymentMethodOrder = listOf(
        "card",
        "google_pay",
        "payjustnow",  // any enabled BNPL; also payflex, float, mobicred, …
    )
)

{
  "payment_method_types": ["card", "google_pay"]
}

{
  "email": "customer@example.com",
  "name": "John Doe"
}

{ "customer_id": "cus_xxx" }

{ "customer_id": "cus_xxx" }

{ "secret": "ek_xxx" }

data class CheckoutResponse(
    @SerializedName("client_secret") val clientSecret: String,
    @SerializedName("customer_id") val customerId: String,
    @SerializedName("ephemeral_key") val ephemeralKey: String
)

fun presentPaymentSheet(response: CheckoutResponse) {
    val customerConfig = PaymentSheet.CustomerConfiguration(
        id = response.customerId,
        ephemeralKeySecret = response.ephemeralKey
    )

    val configuration = PaymentSheet.Configuration(
        merchantDisplayName = "Your Store",
        customer = customerConfig,
        // Control save card behaviour
        allowsDelayedPaymentMethods = true
    )

    paymentSheet.presentWithPaymentIntent(
        paymentIntentClientSecret = response.clientSecret,
        configuration = configuration
    )
}

suspend fun saveCardForLater(customerId: String) {
    // 1. Create Setup Intent on your server
    val setupResponse = api.createSetupIntent(customerId)

    // 2. Configure for Setup Intent
    val configuration = PaymentSheet.Configuration(
        merchantDisplayName = "Your Store",
        customer = PaymentSheet.CustomerConfiguration(
            id = customerId,
            ephemeralKeySecret = setupResponse.ephemeralKey
        )
    )

    // 3. Present with Setup Intent
    paymentSheet.presentWithSetupIntent(
        setupIntentClientSecret = setupResponse.clientSecret,
        configuration = configuration
    )
}

private fun handleSetupResult(result: PaymentSheetResult) {
    when (result) {
        is PaymentSheetResult.Completed -> {
            // Card saved successfully!
            // You can now charge it later from your server
        }
        // ... handle other cases
    }
}

suspend fun loadSavedCards(customerId: String): List<SavedCard> {
    return api.getPaymentMethods(customerId)
}

data class SavedCard(
    val id: String,
    val brand: String,      // "visa", "mastercard"
    val last4: String,      // "4242"
    val expMonth: Int,
    val expYear: Int
)

@Composable
fun SavedCardsList(cards: List<SavedCard>, onSelect: (SavedCard) -> Unit) {
    LazyColumn {
        items(cards) { card ->
            SavedCardItem(
                card = card,
                onClick = { onSelect(card) }
            )
        }
    }
}

@Composable
fun SavedCardItem(card: SavedCard, onClick: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .clickable(onClick = onClick)
            .padding(16.dp)
    ) {
        // Card brand icon
        Icon(
            painter = painterResource(getCardBrandIcon(card.brand)),
            contentDescription = card.brand
        )
        Spacer(Modifier.width(16.dp))
        Column {
            Text("•••• ${card.last4}")
            Text(
                "Expires ${card.expMonth}/${card.expYear}",
                style = MaterialTheme.typography.bodySmall
            )
        }
    }
}

{
  "amount": 6500,
  "currency": "zar",
  "customer_id": "cus_xxx",
  "payment_method": "pm_xxx",
  "off_session": true,
  "confirm": true
}

import io.peachpayments.PaymentSheetResult

private fun handlePaymentResult(result: PaymentSheetResult) {
    when (result) {
        is PaymentSheetResult.Completed -> {
            onPaymentSuccess()
        }
        is PaymentSheetResult.Canceled -> {
            // User dismissed - not an error
            Log.d("Payment", "User canceled")
        }
        is PaymentSheetResult.Failed -> {
            handlePaymentError(result.error)
        }
    }
}

private fun handlePaymentError(error: Throwable) {
    val message = when {
        error is HyperswitchException -> handleHyperswitchError(error)
        error is IOException -> "Network error. Please check your connection."
        error is JsonSyntaxException -> "Invalid response from server."
        else -> error.localizedMessage ?: "An unexpected error occurred."
    }

    showErrorDialog(message)
}

private fun handleHyperswitchError(error: HyperswitchException): String {
    return when (error.code) {
        // Card errors
        "card_declined" -> "Your card was declined. Please try another card."
        "expired_card" -> "Your card has expired."
        "incorrect_cvc" -> "Incorrect security code."
        "insufficient_funds" -> "Insufficient funds."
        "processing_error" -> "Processing error. Please try again."

        // Authentication errors
        "authentication_required" -> "Additional authentication required."
        "authentication_failed" -> "Authentication failed. Please try again."

        // Validation errors
        "invalid_card_number" -> "Invalid card number."
        "invalid_expiry" -> "Invalid expiration date."
        "invalid_cvc" -> "Invalid security code."

        // Other errors
        "rate_limit" -> "Too many requests. Please wait and try again."
        "api_error" -> "Server error. Please try again later."

        else -> error.message ?: "Payment failed."
    }
}

private fun handleNetworkError(context: Context): String {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE)
        as ConnectivityManager

    val network = connectivityManager.activeNetwork
    val capabilities = connectivityManager.getNetworkCapabilities(network)

    return when {
        capabilities == null -> "No internet connection."
        !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) ->
            "No internet access."
        !capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) ->
            "Internet connection is unstable."
        else -> "Network error. Please try again."
    }
}

class PaymentRetryHandler {
    private var retryCount = 0
    private val maxRetries = 3

    suspend fun <T> withRetry(
        shouldRetry: (Throwable) -> Boolean = { it is IOException },
        block: suspend () -> T
    ): T {
        while (true) {
            try {
                return block()
            } catch (e: Throwable) {
                if (shouldRetry(e) && retryCount < maxRetries) {
                    retryCount++
                    delay(retryCount * 2000L)  // Exponential backoff
                } else {
                    throw e
                }
            }
        }
    }
}

val retryHandler = PaymentRetryHandler()
val result = retryHandler.withRetry {
    api.createPaymentIntent(request)
}

private fun showErrorDialog(
    message: String,
    onRetry: (() -> Unit)? = null
) {
    AlertDialog.Builder(this)
        .setTitle("Payment Error")
        .setMessage(message)
        .apply {
            if (onRetry != null) {
                setPositiveButton("Retry") { _, _ -> onRetry() }
                setNegativeButton("Cancel", null)
            } else {
                setPositiveButton("OK", null)
            }
        }
        .show()
}

object PaymentLogger {
    private const val TAG = "HyperswitchPayment"

    fun logError(error: Throwable, context: String = "") {
        if (BuildConfig.DEBUG) {
            Log.e(TAG, "=== Payment Error ===")
            Log.e(TAG, "Context: $context")
            Log.e(TAG, "Type: ${error::class.simpleName}")
            Log.e(TAG, "Message: ${error.message}")
            Log.e(TAG, "Stack trace:", error)
            Log.e(TAG, "====================")
        }

        // In production, send to crash reporting
        // Firebase.crashlytics.recordException(error)
    }
}

import io.peachpayments.PaymentSheet
import android.graphics.Color

fun createAppearance(): PaymentSheet.Appearance {
    return PaymentSheet.Appearance(
        // COLORS
        colors = PaymentSheet.Colors(
            primary = Color.parseColor("#0066FF"),
            surface = Color.WHITE,
            component = Color.parseColor("#F5F5F5"),
            componentBorder = Color.parseColor("#E0E0E0"),
            componentDivider = Color.parseColor("#E0E0E0"),
            onSurface = Color.BLACK,
            onComponent = Color.BLACK,
            subtitle = Color.GRAY,
            placeholderText = Color.parseColor("#9E9E9E"),
            appBarIcon = Color.BLACK,
            error = Color.parseColor("#FF5252")
        ),

        // SHAPES
        shapes = PaymentSheet.Shapes(
            cornerRadiusDp = 12f,
            borderStrokeWidthDp = 1f
        ),

        // TYPOGRAPHY
        typography = PaymentSheet.Typography(
            fontResId = R.font.your_custom_font,  // Optional custom font
            sizeScaleFactor = 1.0f
        ),

        // PRIMARY BUTTON
        primaryButton = PaymentSheet.PrimaryButton(
            colors = PaymentSheet.PrimaryButtonColors(
                background = Color.parseColor("#0066FF"),
                onBackground = Color.WHITE,
                border = Color.TRANSPARENT
            ),
            shape = PaymentSheet.PrimaryButtonShape(
                cornerRadiusDp = 8f,
                borderStrokeWidthDp = 0f
            ),
            typography = PaymentSheet.PrimaryButtonTypography(
                fontResId = R.font.your_custom_font,
                fontSizeSp = 16f
            )
        )
    )
}

object AppearancePresets {

    val light = PaymentSheet.Appearance(
        colors = PaymentSheet.Colors(
            primary = Color.parseColor("#0066FF"),
            surface = Color.WHITE,
            component = Color.parseColor("#F5F5F5"),
            onSurface = Color.BLACK,
            onComponent = Color.BLACK
        ),
        shapes = PaymentSheet.Shapes(cornerRadiusDp = 8f)
    )

    val dark = PaymentSheet.Appearance(
        colors = PaymentSheet.Colors(
            primary = Color.parseColor("#4DA3FF"),
            surface = Color.parseColor("#1A1A1A"),
            component = Color.parseColor("#2D2D2D"),
            onSurface = Color.WHITE,
            onComponent = Color.WHITE
        ),
        shapes = PaymentSheet.Shapes(cornerRadiusDp = 8f)
    )

    val minimal = PaymentSheet.Appearance(
        colors = PaymentSheet.Colors(
            primary = Color.BLACK,
            surface = Color.WHITE
        ),
        shapes = PaymentSheet.Shapes(
            cornerRadiusDp = 0f,
            borderStrokeWidthDp = 0f
        )
    )
}

fun getAppearanceForTheme(context: Context): PaymentSheet.Appearance {
    val isDarkMode = context.resources.configuration.uiMode and
        Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES

    return if (isDarkMode) AppearancePresets.dark else AppearancePresets.light
}

@RequiresApi(Build.VERSION_CODES.S)
fun createDynamicAppearance(context: Context): PaymentSheet.Appearance {
    val dynamicColors = context.getSystemService(Context.UI_MODE_SERVICE)

    return PaymentSheet.Appearance(
        colors = PaymentSheet.Colors(
            primary = context.getColor(android.R.color.system_accent1_500),
            surface = context.getColor(android.R.color.system_neutral1_50),
            component = context.getColor(android.R.color.system_neutral1_100)
        )
    )
}

val appearance = PaymentSheet.Appearance(
    typography = PaymentSheet.Typography(
        fontResId = R.font.roboto_medium,
        sizeScaleFactor = 1.0f
    )
)

<font-family>
    <font app:font="@font/roboto_regular" app:fontWeight="400" />
    <font app:font="@font/roboto_medium" app:fontWeight="500" />
    <font app:font="@font/roboto_bold" app:fontWeight="700" />
</font-family>

android {
    buildTypes {
        debug {
            buildConfigField("String", "HYPERSWITCH_KEY", "\"pk_test_xxx\"")
            buildConfigField("String", "API_URL", "\"https://sandbox.yourserver.com\"")
        }
        release {
            buildConfigField("String", "HYPERSWITCH_KEY", "\"pk_live_xxx\"")
            buildConfigField("String", "API_URL", "\"https://api.yourserver.com\"")
        }
    }
}

@RunWith(AndroidJUnit4::class)
class PaymentViewModelTest {

    @get:Rule
    val instantTaskExecutorRule = InstantTaskExecutorRule()

    private lateinit var viewModel: CheckoutViewModel
    private lateinit var mockApi: PaymentApi

    @Before
    fun setup() {
        mockApi = mockk()
        viewModel = CheckoutViewModel(mockApi)
    }

    @Test
    fun createPaymentIntent_success() = runTest {
        // Arrange
        val expected = PaymentIntentResponse(clientSecret = "pi_xxx_secret_xxx")
        coEvery { mockApi.createPaymentIntent(any()) } returns expected

        // Act
        val result = viewModel.createPaymentIntent(6500, "zar")

        // Assert
        assertEquals(expected.clientSecret, result)
    }

    @Test
    fun createPaymentIntent_networkError() = runTest {
        // Arrange
        coEvery { mockApi.createPaymentIntent(any()) } throws IOException("Network error")

        // Act and assert
        assertThrows<IOException> {
            viewModel.createPaymentIntent(6500, "zar")
        }
    }
}

@RunWith(AndroidJUnit4::class)
@LargeTest
class CheckoutActivityTest {

    @get:Rule
    val activityRule = ActivityScenarioRule(CheckoutActivity::class.java)

    @Test
    fun payButton_isDisplayed() {
        onView(withId(R.id.payButton))
            .check(matches(isDisplayed()))
    }

    @Test
    fun payButton_click_showsLoading() {
        onView(withId(R.id.payButton))
            .perform(click())

        onView(withId(R.id.progressBar))
            .check(matches(isDisplayed()))
    }
}

@RunWith(AndroidJUnit4::class)
class CheckoutScreenTest {

    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun checkoutScreen_displaysAmount() {
        composeTestRule.setContent {
            CheckoutScreen(amount = 6500, currency = "ZAR")
        }

        composeTestRule
            .onNodeWithText("R65.00")
            .assertIsDisplayed()
    }
}

adb logcat -s Hyperswitch

class CheckoutActivity : AppCompatActivity() {
    private lateinit var paymentSession: PaymentSession

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        paymentSession = PaymentSession(this, "pk_test_xxx")
    }
}

class CheckoutActivity : AppCompatActivity() {
    private lateinit var paymentSession: PaymentSession

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // CORRECT: Initialise here
        paymentSession = PaymentSession(this, "pk_test_xxx")
    }

    // WRONG: Don't initialise in button click
    fun onPayClicked() {
        // paymentSession = PaymentSession(this, "pk_test_xxx")  // TOO LATE!
    }
}

fun checkGooglePayAvailability(context: Context) {
    val paymentsClient = Wallet.getPaymentsClient(
        context,
        Wallet.WalletOptions.Builder()
            .setEnvironment(WalletConstants.ENVIRONMENT_TEST)
            .build()
    )

    val request = IsReadyToPayRequest.fromJson(/* your config */)
    paymentsClient.isReadyToPay(request).addOnCompleteListener { task ->
        Log.d("GooglePay", "Available: ${task.result}")
    }
}

<activity android:name=".CheckoutActivity"
    android:launchMode="singleTask">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="yourapp" android:host="payment-return" />
    </intent-filter>
</activity>

configurations.all {
    exclude group: 'com.google.protobuf', module: 'protobuf-lite'
}

class CheckoutActivity : AppCompatActivity() {
    override fun onDestroy() {
        super.onDestroy()
        // PaymentSheet is lifecycle-aware, no manual cleanup needed
    }
}