Mobile solutions

import VinrSDK

let terminal = VINRTerminal(secretKey: ProcessInfo.processInfo.environment["VINR_SECRET_KEY"]!)

terminal.discoverReaders(connectionConfig: .bluetooth) { result in
    switch result {
    case .success(let readers):
        guard let cm30 = readers.first(where: { $0.model == .cm30 }) else { return }

        terminal.connectReader(cm30) { connectResult in
            switch connectResult {
            case .success:
                let params = VINRPaymentParams(
                    amount: 2500,
                    currency: "USD",
                    reference: "order_8821"
                )

                terminal.createPayment(params: params) { createResult in
                    switch createResult {
                    case .success(let intent):
                        terminal.collectPayment(intent: intent) { collectResult in
                            switch collectResult {
                            case .success(let confirmedIntent):
                                print("Payment succeeded:", confirmedIntent.id)
                            case .failure(let error):
                                print("Collection failed:", error.localizedDescription)
                            }
                        }
                    case .failure(let error):
                        print("Create failed:", error.localizedDescription)
                    }
                }

            case .failure(let error):
                print("Connect failed:", error.localizedDescription)
            }
        }

    case .failure(let error):
        print("Discovery failed:", error.localizedDescription)
    }
}

import com.vinr.sdk.Vinr
import com.vinr.sdk.terminal.VinrTerminal
import com.vinr.sdk.terminal.ConnectionConfig
import com.vinr.sdk.terminal.PaymentParams

val vinr = Vinr(secretKey = System.getenv("VINR_SECRET_KEY"))
val terminal = VinrTerminal(vinr)

terminal.discoverReaders(ConnectionConfig.Bluetooth) { result ->
    result.onSuccess { readers ->
        val cm30 = readers.firstOrNull { it.model == ReaderModel.CM30 } ?: return@onSuccess

        terminal.connectReader(cm30) { connectResult ->
            connectResult.onSuccess {
                val params = PaymentParams(
                    amount = 2500L,
                    currency = "USD",
                    reference = "order_8821"
                )

                terminal.createPayment(params) { createResult ->
                    createResult.onSuccess { intent ->
                        terminal.collectPayment(intent) { collectResult ->
                            collectResult.onSuccess { confirmedIntent ->
                                println("Payment succeeded: ${confirmedIntent.id}")
                            }.onFailure { error ->
                                println("Collection failed: ${error.message}")
                            }
                        }
                    }.onFailure { error ->
                        println("Create failed: ${error.message}")
                    }
                }
            }.onFailure { error ->
                println("Connect failed: ${error.message}")
            }
        }
    }.onFailure { error ->
        println("Discovery failed: ${error.message}")
    }
}

terminal.delegate = self

extension YourClass: VINRTerminalDelegate {
    func terminal(_ terminal: VINRTerminal, didUpdateReaderConnectionStatus status: VINRReaderConnectionStatus) {
        switch status {
        case .connected(let reader):
            print("Reader connected — battery:", reader.batteryLevel ?? "unknown")
        case .disconnected(let reader, let reason):
            print("Reader disconnected:", reason)
            terminal.reconnectReader(reader, retryPolicy: .exponentialBackoff(maxAttempts: 5)) { _ in }
        case .batteryLow(let reader):
            showOperatorAlert("CM30 battery is low. Please charge the reader soon.")
        }
    }
}

terminal.setConnectionListener(object : VinrConnectionListener {
    override fun onReaderConnected(reader: Reader) {
        println("Reader connected — battery: ${reader.batteryLevel ?: "unknown"}")
    }

    override fun onReaderDisconnected(reader: Reader, reason: DisconnectReason) {
        println("Reader disconnected: $reason")
        terminal.reconnectReader(reader, RetryPolicy.ExponentialBackoff(maxAttempts = 5)) {}
    }

    override fun onBatteryLow(reader: Reader) {
        showOperatorAlert("CM30 battery is low. Please charge the reader soon.")
    }
})