Android SDK

repositories {
    maven { url = uri("https://yunopayments.jfrog.io/artifactory/snapshots-libs-release") }
}

dependencies {
    implementation("com.yuno.payments:android-sdk:{last_version}")
}

import com.yuno.sdk.Yuno
import com.yuno.sdk.YunoConfig
import android.app.Application

class CustomApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        Yuno.initialize(
            this,
            "your-public-api-key",
            YunoConfig()
        )
    }
}

<application
    android:name=".CustomApplication"
    ...>
</application>

data class YunoConfig(
    val cardFlow: CardFormType = CardFormType.ONE_STEP,
    val saveCardEnabled: Boolean = false,
    val cardFormDeployed: Boolean = false,
    val language: YunoLanguage? = null,
    val styles: YunoStyles? = null
)

enum class YunoLanguage {
    SPANISH,
    ENGLISH,
    PORTUGUESE,
    INDONESIAN,
    MALAYSIAN,
    FRENCH,
    POLISH,
    ITALIAN,
    GERMAN,
    RUSSIAN,
    TURKISH,
    DUTCH,
    SWEDISH,
    THAI,
    FILIPINO,
    VIETNAMESE,
    CHINESE_SIMPLIFIED,
    CHINESE_TRADITIONAL
}

import androidx.appcompat.app.AppCompatActivity
import com.yuno.sdk.payments.startCheckout
import com.yuno.sdk.payments.startPayment
import com.yuno.sdk.payments.continuePayment
import com.yuno.sdk.payments.updateCheckoutSession

class PaymentActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_payment)
        
        // Step 1: Initialize checkout in onCreate
        startCheckout(
            callbackPaymentState = ::onPaymentStateChange
        )
        
        setupPaymentMethodsView()
    }
    
    private fun setupPaymentMethodsView() {
        // Step 2: Update checkout session with your session ID and country
        updateCheckoutSession(
            checkoutSession = "your_checkout_session_id",
            countryCode = "CO"
        )
        
        // Step 3: Display payment methods using Compose view
        val composeView = findViewById<ComposeView>(R.id.paymentMethodsContainer)
        composeView.setContent {
            PaymentMethodListViewComponent(
                activity = this@PaymentActivity,
                onPaymentSelected = { isSelected ->
                    findViewById<Button>(R.id.payButton).isEnabled = isSelected
                }
            )
        }
    }
    
    private fun processPayment() {
        // Step 4: Start payment when user clicks pay button
        startPayment(
            callbackOTT = ::onTokenReceived
        )
    }
    
    private fun onTokenReceived(token: String?) {
        token?.let {
            // Step 5: Send token to your backend to create payment
            createPaymentOnBackend(it)
        }
    }
    
    private fun createPaymentOnBackend(token: String) {
        // Call your backend API to create payment with the token
        // If response has sdk_action_required = true, call continuePayment()
    }
    
    private fun handleSdkActionRequired() {
        // Step 6: Continue payment if sdk_action_required is true
        continuePayment(
            callbackPaymentState = ::onPaymentStateChange
        )
    }
    
    private fun onPaymentStateChange(paymentState: String?, paymentSubState: String?) {
        when (paymentState) {
            "SUCCEEDED" -> {
                // Payment successful
                navigateToSuccess()
            }
            "FAIL" -> {
                // Payment failed
                showError("Payment failed")
            }
            "PROCESSING" -> {
                // Payment is being processed
                showPendingMessage()
            }
            "REJECT" -> {
                // Payment was rejected
                showError("Payment rejected")
            }
            "INTERNAL_ERROR" -> {
                // Internal error occurred
                showError("An error occurred")
            }
            "CANCELED" -> {
                // User canceled
                Toast.makeText(this, "Payment canceled", Toast.LENGTH_SHORT).show()
            }
        }
        // paymentSubState provides additional details about the payment status
    }
}

<com.yuno.payments.features.payment.ui.views.PaymentMethodListView
    android:id="@+id/list_payment_methods"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

<androidx.compose.ui.platform.ComposeView
    android:id="@+id/paymentMethodsContainer"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

import com.yuno.sdk.payments.startCheckout
import com.yuno.sdk.payments.startPaymentLite
import com.yuno.sdk.payments.continuePayment
import com.yuno.sdk.payments.updateCheckoutSession
import com.yuno.presentation.core.components.PaymentSelected

class CheckoutLiteActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_checkout_lite)
        
        // Initialize checkout
        startCheckout(
            checkoutSession = "your_checkout_session_id",
            countryCode = "CO",
            callbackPaymentState = ::onPaymentStateChange
        )
    }
    
    private fun processPayment(paymentMethodType: String, vaultedToken: String?) {
        // Start payment with selected payment method
        startPaymentLite(
            paymentSelected = PaymentSelected(
                paymentMethodType = paymentMethodType,
                vaultedToken = vaultedToken
            ),
            callBackTokenWithInformation = { ottModel ->
                // Optional: Receive additional token information
                Log.i("OTT Info", ottModel.toString())
            },
            callbackOTT = ::onTokenReceived
        )
    }
    
    private fun onTokenReceived(token: String?) {
        token?.let {
            // Send token to your backend
            createPaymentOnBackend(it)
        }
    }
    
    private fun onPaymentStateChange(paymentState: String?, paymentSubState: String?) {
        // Handle payment state changes
        // paymentSubState provides additional details about the payment status
    }
}

const val PAYMENT_STATE_SUCCEEDED = "SUCCEEDED"
const val PAYMENT_STATE_FAIL = "FAIL"
const val PAYMENT_STATE_PROCESSING = "PROCESSING"
const val PAYMENT_STATE_REJECT = "REJECT"
const val PAYMENT_STATE_INTERNAL_ERROR = "INTERNAL_ERROR"
const val PAYMENT_STATE_CANCELED = "CANCELED"

private fun onTokenReceived(token: String?) {
    token?.let {
        lifecycleScope.launch {
            val response = createPaymentOnBackend(it)
            
            if (response.sdkActionRequired) {
                continuePayment(
                    callbackPaymentState = ::onPaymentStateChange
                )
            }
        }
    }
}

# Yuno SDK
-keep class com.yuno.sdk.** { *; }
-keep interface com.yuno.sdk.** { *; }
-dontwarn com.yuno.sdk.**

# OkHttp & Retrofit
-dontwarn okhttp3.**
-dontwarn retrofit2.**