Developer Documents

Environment

Currently available there’s only 2 environments.

1. MITE or TEST
2. LIVE

You can choose between each environment by completing 2 steps:

1. Use your Environment specific credentials set (username, password, installationId) to generate your authentication (client) token
2. Set the Environment enum inside the PaymentConfig to the specific environment

Available Environment enums: Environment.TEST or Environment.LIVE (lowercase for iOS)

Payment Config

To setup a payment and its details, you need to create a data class called PaymentConfig:

import com.accesspaysuite.mobilesdk.PaymentConfig

val myPaymentConfig = PaymentConfig(
    installationId = installationId,
    countryCode = "GBR",
    currencyCode = "GBP",
    transactionType = TransactionType.PAYMENT,
    clientToken = clientToken,
    transaction = TransactionDetails(
        amount = 10.0,
        currency = "GBP",
        merchantRef = "Test_order",
        recurring = false,
        deferred = false,
        continuousAuthorityAgreement = null
    ),
    customer = CustomerDetails(
        email = "[email protected]",
        dob = "19870818",
        telephone = "0123 456 789",
        customerRef = "your_unique_customer_ref"
        registered = true,
    ),
    financialServices = FinancialDetails(
        dateOfBirth = "19870818",
        surname = "John",
        accountNumber = "1234561234",
        postCode = "EC2A"
    ),
    environment = Environment.TEST
)

Payment Processor Setup

The Setup is required to set all the necessary callbacks like when the user enters a card successfully or not, if the payment method is canceled by the user, if the payment result was success or if it failed and why.

Android Example

The only difference between the Android and iOS setup would be the existence of the Android Context in the constructor of the Payment Processor

Create the PaymentProcessor

val processor = PaymentProcessor(
    config = myPaymentConfig,
    context = context // The Android Context
)

Payment Result Callback

processor.setPaymentResultCallback(
    object : PaymentResultCallback {
        override fun onPaymentResult(status: Status) {
            when (status) {
                Status.Canceled -> {
                    // User canceled the payment method
                    // This usually happens when the user proceeds the Google/Apple Pay process but cancels before completing.
                }

                is Status.Error -> {
                    // Payment method failed
                    val error = status.message
                    val traceId = status.traceId
                    // Trace id can be sent over for further information about the error.
                }

                Status.SessionExpired -> {
                    // Session expired
                }

                Status.Success -> {
                    // Payment was successful
                }

                else -> {
                    // Handle unknown cases
                }
            }
        }
    }
)
// OR
processor.setPaymentResultCallback(
    onPaymentSuccess = {
        // Payment was successful
    },
    onPaymentFailed = { error, traceId ->
        // Payment method failed
        // If session expires, then the error argument will be "Session expired"
    },
    onPaymentMethodCanceled = {
        // User canceled the payment method
    }
)

Card Submission Callback

// This callback can be used to control your UI to respond
// properly when the Cardholder information is complete or
// contains errors
processor.setCardCallback(
    onCardSubmittedSuccessfully = {
        // Card submitted successfully
    },
    onCardSubmittedWithErrors = { errors ->
        // Card submitted with errors
    
        // All errors mapped to a single string
        val errorsToString = errors.mapToString(separator = "\n")
    }
)

Payment Initiation

Required before attempting any payment methods

processor.initiate {
    if (status == Status.Initiated) {
        // Initiated successfully
    } else {
        // Could not initiate
        // Can be casted as Status.Error for further details
    }
}

Compose Multiplatform Example

// The PaymentProcessor for Compose does not require any extra setup
// The initiate process is called after declaration
val processor = rememberPaymentProcessor(
    paymentConfig = myPaymentConfig,
    onPaymentSuccess = {
        // Payment was successful
    },
    onPaymentFailed = { reason, traceId ->
        // Payment method failed
        // If session expires, then the error argument will be "Session expired"
    },
    onPaymentMethodCanceled = {
        // User canceled the payment method
    },
    onCardSubmittedSuccessfully = {
        // Card submitted successfully
    },
    onCardSubmittedWithErrors = { errors ->
        // Card submitted with errors
    },
    onInitiate = { status ->
        if (status == Status.Initiated) {
            // Initiated successfully
        } else {
            // Could not initiate
        }
    }
)

iOS Example

Similar to the Android Example

Create the PaymentProcessor

var processor = PaymentProcessor(config: paymentConfig)

Payment Result Callback

processor.setPaymentResultCallback {
    // Success
} onPaymentFailed: { reason, traceId in
    // Failed
    // traceId is a nullable String
} onPaymentMethodCanceled: {
    // Method canceled
}
// OR
processor.setPaymentResultCallback(callback: <any PaymentResultCallback>)

Card Submission Callback

// This callback can be used to control your UI to respond
// properly when the Cardholder information is complete or
// contains errors
processor.setCardCallback {
    // Card submitted successfully
} onCardSubmittedWithErrors: { errors in
    // Card has errors
}

Payment Initiation

Required before attempting any payment methods

processor.initiate { status in
    if (status is Status.Initiated) {
        // Initiated successfully
    } else {
        // Could not initiate
        // Can be casted as Status.Error for further details
    }
}