Payments & PSP Integration

Copy code// implementation("com.stripe:stripe-android:20.37.5")

class PaymentManager(private val context: Context) {
    private val paymentSheet: PaymentSheet

    init {
        PaymentConfiguration.init(context, BuildConfig.STRIPE_PUBLISHABLE_KEY)
        paymentSheet = PaymentSheet(activity, ::onPaymentResult)
    }

    // Step 1: Get client secret from your server (never from client)
    suspend fun initiatePayment(cartTotal: Int): String {
        // Your server creates a PaymentIntent and returns the client secret
        return serverApi.createPaymentIntent(amount = cartTotal, currency = "usd").clientSecret
    }

    // Step 2: Present Stripe's hosted payment sheet
    fun presentPaymentSheet(clientSecret: String) {
        val configuration = PaymentSheet.Configuration(
            merchantDisplayName = "My Shop",
            allowsDelayedPaymentMethods = false,
            googlePay = PaymentSheet.GooglePayConfiguration(
                environment = PaymentSheet.GooglePayConfiguration.Environment.Production,
                countryCode = "US",
                currencyCode = "USD"
            )
        )
        paymentSheet.presentWithPaymentIntent(clientSecret, configuration)
    }

    // Step 3: Handle result
    private fun onPaymentResult(result: PaymentSheetResult) {
        when (result) {
            is PaymentSheetResult.Completed -> onPaymentSuccess()
            is PaymentSheetResult.Canceled  -> onPaymentCanceled()
            is PaymentSheetResult.Failed    -> onPaymentFailed(result.error)
        }
    }
}

Copy codeclass GooglePayManager(private val activity: Activity) {
    private val paymentsClient: PaymentsClient = Wallet.getPaymentsClient(
        activity,
        Wallet.WalletOptions.Builder()
            .setEnvironment(WalletConstants.ENVIRONMENT_PRODUCTION)
            .build()
    )

    // Check if Google Pay is available
    suspend fun isGooglePayAvailable(): Boolean {
        val request = IsReadyToPayRequest.fromJson(buildIsReadyToPayJson())
        return paymentsClient.isReadyToPay(request).await()
    }

    // Launch Google Pay sheet
    fun launchGooglePay(priceInCents: Long) {
        val request = PaymentDataRequest.fromJson(buildPaymentDataRequestJson(priceInCents))
        // Launch via AutoResolveHelper or Activity Result API
        AutoResolveHelper.resolveTask(
            paymentsClient.loadPaymentData(request),
            activity,
            GOOGLE_PAY_REQUEST_CODE
        )
    }

    // Handle result in onActivityResult
    fun handleGooglePayResult(resultCode: Int, data: Intent?): GooglePayResult {
        return when (resultCode) {
            Activity.RESULT_OK -> {
                val paymentData = PaymentData.getFromIntent(data!!)
                val token = paymentData?.toJson()?.let {
                    JSONObject(it).getJSONObject("paymentMethodData")
                        .getJSONObject("tokenizationData")
                        .getString("token")
                }
                GooglePayResult.Success(token ?: "")
            }
            Activity.RESULT_CANCELED -> GooglePayResult.Canceled
            else -> GooglePayResult.Failed(AutoResolveHelper.getStatusFromIntent(data))
        }
    }
}

Copy codesealed class PaymentResult {
    object Success : PaymentResult()
    data class RequiresAction(val redirectUrl: String) : PaymentResult()  // 3D Secure
    data class Failed(val code: String, val message: String) : PaymentResult()
}

class CheckoutViewModel(
    private val paymentManager: PaymentManager,
    private val orderRepository: OrderRepository
) : ViewModel() {

    fun checkout(cartId: String) = viewModelScope.launch {
        _state.update { it.copy(isProcessing = true) }

        try {
            // 1. Create order (reserving inventory)
            val order = orderRepository.createOrder(cartId)

            // 2. Get payment intent from server
            val clientSecret = paymentManager.initiatePayment(order.totalCents)

            // 3. Present payment UI
            paymentManager.presentPaymentSheet(clientSecret)

            // Payment result handled asynchronously via callback
        } catch (e: Exception) {
            _state.update { it.copy(isProcessing = false, error = e.message) }
        }
    }

    // Called from payment result callback
    fun onPaymentSuccess(orderId: String) {
        viewModelScope.launch {
            // Confirm order server-side (server verifies payment with Stripe webhook)
            orderRepository.confirmOrder(orderId)
            _state.update { it.copy(isProcessing = false, isSuccess = true) }
        }
    }
}

Copy code// Always pass an idempotency key when creating payment intents server-side
// If the same request is retried (network failure after server received it),
// the server returns the same PaymentIntent instead of creating a new charge

data class CreatePaymentIntentRequest(
    val amount: Int,
    val currency: String,
    val orderId: String,         // use orderId as idempotency key
    val customerId: String
)