SDK Android

dependencies {
    implementation("com.cubopago:possdk:<version>")
}

private val permissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestMultiplePermissions()
) { results ->
    if (results.all { it.value }) {
        initializeSdk()
    } else {
        showError("Permisos requeridos no otorgados")
    }
}
 
private fun requestPermissions() {
    val permissions = mutableListOf(
        Manifest.permission.ACCESS_FINE_LOCATION
    )
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        permissions.add(Manifest.permission.BLUETOOTH_SCAN)
        permissions.add(Manifest.permission.BLUETOOTH_CONNECT)
    }
    permissionLauncher.launch(permissions.toTypedArray())
}

val authConfig = CuboAuthConfig.ApiKey("pk_live_your_api_key")

CuboPosSDK.init(
    CuboConfig(
        context = applicationContext,
        authConfig = CuboAuthConfig.ApiKey("pk_live_your_api_key"),
        environment = CuboEnvironment.SANDBOX,
        enableLogging = BuildConfig.DEBUG,
        enableMsi = false
    )
)

Tu App                      CuboPosSDK
   |                            |
   |-- init(config) ----------->|
   |-- setConnectionListener -->|
   |-- scanAndConnect() ------->|  (SDK muestra bottom sheet)
   |                            |  (usuario selecciona dispositivo)
   |<-- onConnectionStatus -----|  (SCANNING → CONNECTING → CONFIGURING → CONNECTED)
   |<-- onDeviceReady(info) ----|  (POS listo para pagos)

CuboPosSDK.connection().setConnectionListener(this)
CuboPosSDK.connection().scanAndConnect(activity = this, timeoutSeconds = 30)

interface CuboConnectionListener {
    fun onConnectionStatusChanged(status: ConnectionStatus)
    fun onDeviceFound(device: CuboDevice)       // No necesario con scanAndConnect()
    fun onDeviceReady(posInfo: CuboPosInfo)
    fun onConnectionError(error: CuboConnectionError)
}

override fun onConnectionError(error: CuboConnectionError) {
    when (error) {
        is CuboConnectionError.BluetoothDisabled ->
            showError("Activa el Bluetooth")
 
        is CuboConnectionError.BluetoothPermissionsDenied ->
            showError("Permisos de Bluetooth denegados")
 
        is CuboConnectionError.LocationPermissionDenied ->
            showError("Permiso de ubicación denegado")
 
        is CuboConnectionError.ScanTimeout ->
            showError("No se encontraron dispositivos")
 
        is CuboConnectionError.DeviceNotFound ->
            showError("Dispositivo no encontrado")
 
        is CuboConnectionError.ConnectionFailed ->
            showError("Falló la conexión, intenta de nuevo")
 
        is CuboConnectionError.PosNotRegistered ->
            showError("POS no registrado — contacta a Cubo")
 
        is CuboConnectionError.RegistrationFailed ->
            showError("Error de red al registrar POS")
 
        is CuboConnectionError.EmvUpdateFailed ->
            showError("Error actualizando configuración")
 
        is CuboConnectionError.LocationUnavailable ->
            showError("Ubicación no disponible")
 
        is CuboConnectionError.Unknown ->
            showError(error.message)
    }
}

CuboPosSDK.connection().disconnect()                 // Desconectar del POS
CuboPosSDK.connection().isPosConnected()             // Verificar si está conectado
CuboPosSDK.connection().getConnectedPosInfo()        // Obtener info del POS conectado
CuboPosSDK.connection().getConnectionStatus()        // Obtener estado actual
CuboPosSDK.connection().removeConnectionListener()   // Remover listener

Tu App                      CuboPosSDK                     POS
   |                            |                              |
   |-- startPaymentWithUI() --->|  (SDK muestra bottom sheet)  |
   |                            |-- configurar + leer tarjeta >|
   |                            |                              |  (usuario acerca/inserta tarjeta)
   |                            |  (EMV, PIN, selección AID)   |
   |                            |-- llamada API -- Cubo API -->|
   |                            |  (firma si es necesario)     |
   |<-- onTransactionComplete --|                              |
   |    (resultado + tickets)   |                              |

CuboPosSDK.transaction().setTransactionListener(this)
 
CuboPosSDK.transaction().startPaymentWithUI(
    activity = this,
    request = CuboTransactionRequest(
        amountInCents = 1500,       // $15.00
        currency = CuboCurrency.USD
    )
)

// Cancela una transacción en curso en cualquier momento
CuboPosSDK.transaction().cancelTransaction()
// Dispara onTransactionError(CuboTransactionError.TransactionCancelled)

interface CuboTransactionListener {
    fun onWaitingForCard()
    fun onCardRead(readType: CuboReadType)
    fun onProcessingTransaction()
    fun onTransactionComplete(result: CuboTransactionResult)
    fun onTransactionError(error: CuboTransactionError)
}

data class CuboTransactionResult(
    val transactionId: Int,
    val paymentIntentToken: String,
    val status: CuboTransactionStatus,    // SUCCEEDED, DECLINED, ERROR, CANCELLED
    val amount: String,                   // "15.00"
    val currency: CuboCurrency,
    val readType: CuboReadType,           // NFC, CHIP o MAGSTRIPE
    val cardLastDigits: String,           // "1234"
    val cardBrand: String,                // "VISA", "MASTERCARD", etc.
    val authorizationCode: String?,
    val referenceId: String?,
    val clientName: String?,
    val companyTicket: CuboTicket?,       // Copia del comercio
    val clientTicket: CuboTicket?,        // Copia del cliente
    val signatureBitmap: Bitmap?,         // Firma capturada (null si no se requiere)
    val createdAt: String
)

override fun onTransactionError(error: CuboTransactionError) {
    when (error) {
        is CuboTransactionError.DeviceNotConnected ->
            showError("POS no conectado")
 
        is CuboTransactionError.TransactionCancelled ->
            showInfo("Transacción cancelada")
 
        is CuboTransactionError.CardReadFailed ->
            showError("Error leyendo tarjeta, intenta de nuevo")
 
        is CuboTransactionError.CardNotSupported ->
            showError("Tarjeta no soportada")
 
        is CuboTransactionError.EmvError ->
            showError("Error EMV, intenta de nuevo")
 
        is CuboTransactionError.PinCancelled ->
            showError("PIN cancelado")
 
        is CuboTransactionError.ApiError ->
            showError("Error de red, verifica tu conexión")
 
        is CuboTransactionError.Timeout ->
            showError("Tiempo agotado, intenta de nuevo")
 
        is CuboTransactionError.Declined ->
            showError("Transacción rechazada")
 
        is CuboTransactionError.Unknown ->
            showError(error.message)
    }
}

CuboPosSDK.init(
    CuboConfig(
        context = applicationContext,
        authConfig = CuboAuthConfig.ApiKey("pk_live_your_key"),
        enableMsi = true
    )
)
 
// El bottom sheet de pago mostrará las opciones de cuotas automáticamente
CuboPosSDK.transaction().startPaymentWithUI(this, request)

class PaymentActivity : AppCompatActivity(), CuboConnectionListener, CuboTransactionListener {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_payment)
        requestPermissions()
    }
 
    // --- Permisos ---
 
    private val permissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { results ->
        if (results.all { it.value }) initializeSdk()
        else showError("Permisos requeridos")
    }
 
    private fun requestPermissions() {
        val permissions = mutableListOf(Manifest.permission.ACCESS_FINE_LOCATION)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            permissions.add(Manifest.permission.BLUETOOTH_SCAN)
            permissions.add(Manifest.permission.BLUETOOTH_CONNECT)
        }
        permissionLauncher.launch(permissions.toTypedArray())
    }
 
    // --- Inicialización + Conexión ---
 
    private fun initializeSdk() {
        CuboPosSDK.init(
            CuboConfig(
                context = applicationContext,
                authConfig = CuboAuthConfig.ApiKey("pk_live_your_key_here"),
                environment = CuboEnvironment.SANDBOX,
                enableLogging = BuildConfig.DEBUG
            )
        )
 
        CuboPosSDK.connection().setConnectionListener(this)
        CuboPosSDK.connection().scanAndConnect(this, timeoutSeconds = 30)
    }
 
    // --- CuboConnectionListener ---
 
    override fun onConnectionStatusChanged(status: ConnectionStatus) {}
    override fun onDeviceFound(device: CuboDevice) {}
 
    override fun onDeviceReady(posInfo: CuboPosInfo) {
        runOnUiThread {
            showStatus("POS listo")
            CuboPosSDK.transaction().setTransactionListener(this)
            enablePayButton()
        }
    }
 
    override fun onConnectionError(error: CuboConnectionError) {
        runOnUiThread { showError("Error: $error") }
    }
 
    // --- Pago ---
 
    fun onPayButtonClicked(amountInCents: Long) {
        if (!CuboPosSDK.connection().isPosConnected()) {
            showError("POS no conectado")
            return
        }
        CuboPosSDK.transaction().startPaymentWithUI(
            activity = this,
            request = CuboTransactionRequest(
                amountInCents = amountInCents,
                currency = CuboCurrency.USD
            )
        )
    }
 
    // --- CuboTransactionListener ---
 
    override fun onWaitingForCard() {}
    override fun onCardRead(readType: CuboReadType) {}
    override fun onProcessingTransaction() {}
 
    override fun onTransactionComplete(result: CuboTransactionResult) {
        result.companyTicket?.let { printReceipt(it) }
    }
 
    override fun onTransactionError(error: CuboTransactionError) {
        Log.w("MyApp", "Error: $error")
    }
 
    // --- Ciclo de vida ---
 
    override fun onDestroy() {
        super.onDestroy()
        CuboPosSDK.transaction().removeTransactionListener()
        CuboPosSDK.connection().removeConnectionListener()
        CuboPosSDK.shutdown()
    }
}

class MainActivity : AppCompatActivity() {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        requestPermissions()
 
        setContent {
            NavHost(navController, startDestination = "home") {
                composable("home") { HomeScreen(navController) }
                composable("payment") { PaymentScreen(navController) }
                composable("receipt") { ReceiptScreen(navController) }
            }
        }
    }
}

override fun onResume() {
    super.onResume()
    CuboPosSDK.connection().setConnectionListener(this)
    if (!CuboPosSDK.connection().isPosConnected()) {
        CuboPosSDK.connection().scanAndConnect(this)
    }
}
 
override fun onPause() {
    super.onPause()
    CuboPosSDK.connection().disconnect()
    CuboPosSDK.connection().removeConnectionListener()
}

// ✅ Correcto: inicializar una vez
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        CuboPosSDK.init(config)
    }
}
 
// ❌ Incorrecto: inicializar cada vez que te conectas
override fun onResume() {
    CuboPosSDK.init(config)  // Innecesario — ya fue inicializado
    CuboPosSDK.connection().scanAndConnect(this)
}

fun startPayment(amount: Long) {
    if (!CuboPosSDK.connection().isPosConnected()) {
        showError("POS no conectado")
        return
    }
    CuboPosSDK.transaction().startPaymentWithUI(this, request)
}

override fun onDestroy() {
    super.onDestroy()
    CuboPosSDK.transaction().removeTransactionListener()
    CuboPosSDK.connection().removeConnectionListener()
    CuboPosSDK.shutdown()
}

import com.cubopago.possdk.CuboPosSDK
import com.cubopago.possdk.CuboConfig
import com.cubopago.possdk.auth.CuboAuthConfig
import com.cubopago.possdk.models.CuboEnvironment
import com.cubopago.possdk.connection.CuboConnectionListener
import com.cubopago.possdk.models.ConnectionStatus
import com.cubopago.possdk.models.CuboConnectionError
import com.cubopago.possdk.models.CuboDevice
import com.cubopago.possdk.models.CuboPosInfo
import com.cubopago.possdk.transaction.CuboTransactionListener
import com.cubopago.possdk.transaction.CuboTransactionRequest
import com.cubopago.possdk.transaction.CuboTransactionResult
import com.cubopago.possdk.transaction.CuboTransactionError
import com.cubopago.possdk.transaction.CuboCurrency
import com.cubopago.possdk.transaction.CuboReadType
import com.cubopago.possdk.models.CuboTicket