The Judo builder is at the heart of the Android Mobile SDK. This class is responsible for:

Step One: Import some of the classes and properties from the com.judopay package as detailed below:

import com.judopay.Judo 1


import com.judopay.model.Amount 2
import com.judopay.model.Reference
import com.judopay.model.PaymentWidgetType


import com.judopay.PAYMENT_CANCELLED 3
import com.judopay.PAYMENT_ERROR
import com.judopay.PAYMENT_SUCCESS


import com.judopay.JudoActivity 4

val amount = Amount.Builder()
              .setAmount("150.50")
              .setCurrency(Currency.GBP)
              .build()

val reference = Reference.Builder()                 
.setConsumerReference('my-consumer-reference')                 
.build()

val judo = Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
            .setApiToken("my-token")
            .setApiSecret("my-secret")
            .setIsSandboxed(true)
            .setJudoId("my-judo-id")
            .setAmount(amount)
            .setReference(reference)
            .build()

Each transaction operation is represented as an Activity. 

To make a transaction:

val intent = Intent(this, JudoActivity::class.java);
intent.putExtra(Judo.JUDO_OPTIONS, judo);
startActivityForResult(intent, PAYMENT_REQUEST_CODE);

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)

    if (requestCode == PAYMENT_REQUEST_CODE) {
        when (resultCode) {

            PAYMENT_CANCELLED -> toast("User cancelled the payment.")

            PAYMENT_SUCCESS -> {
                val receipt = data?.getParcelableExtra<Receipt>(JUDO_RECEIPT)
                // Handle response
            }

            PAYMENT_ERROR -> {
                val error = data?.getParcelableExtra<JudoError>(JUDO_ERROR)
                // Handle error
            }
        }
    }
}

Check the request code from the onActivityResult and see if it matches with the PAYMENT_REQUEST_CODE. If it does, the result is called from the JudoActivity.

This means the imported response codes can be used to check the following possible response type and handle each case respectively:

To set a server-to-server transaction:

val judo = Judo.Builder(PaymentWidgetType.SERVER_TO_SERVER_PAYMENT_METHODS)
            .setApiToken("my-token")
            .setApiSecret("my-secret")
            .setIsSandboxed(true)
            .setJudoId("my-judo-id")
            .setAmount(amount)
            .setReference(reference)
            .build()

If you are building your own card wallet, and not using a UI you can make a preauth or transaction using a stored card token.

Steps:

Billing Address | primary account details | CV2 are optional fields.

yourConsumerReference | yourPaymentReference | amount | currency | judo ID are mandatory fields.

val service = JudoApiServiceFactory.createApiService(this, judo)

service.tokenPayment(judo.toTokenRequest(cardToken, "452"))
service.preAuthTokenPayment(judo.toTokenRequest(cardToken, "452"))

// Make a token payment API call via JudoApiService
service.tokenPayment(getJudo(judo).toTokenPayment(cardToken, "452"))
    .enqueue(object: Callback<JudoApiCallResult<Receipt>> {
        // Handle failure response
        override fun onFailure(call: Call<JudoApiCallResult<Receipt>>, t: Throwable) {
            TODO("Not yet implemented")
        }
        // Handle successful response
        override fun onResponse(
            call: Call<JudoApiCallResult<Receipt>>,
            response: Response<JudoApiCallResult<Receipt>>
        ) {
            when (val apiResult = response.body()) {
                is JudoApiCallResult.Success -> {
                    val receipt = apiResult.data
                    // Check if 3DS authentication is required
                    if (receipt != null && receipt.is3dSecureRequired) {
                        // Callback that handles 3DS response from SDK
                        val callback = object : ThreeDSOneCompletionCallback {
                            // Handle 3DS successful authentication
                            override fun onSuccess(success: JudoPaymentResult) {
                                setResult(success.code, success.toIntent())
                                finish()
                            }
                            // Handle 3DS unsuccessful authentication
                            override fun onFailure(error: JudoPaymentResult) {
                                setResult(error.code, error.toIntent())
                                finish()
                            }
                        }
                        // Fragment that handles 3DS webview logic
                        val fragment = ThreeDSOneCardVerificationDialogFragment(
                            service,
                            receipt.toCardVerificationModel(),
                            callback
                        )
                        fragment.show(
                            supportFragmentManager,
                            THREE_DS_ONE_DIALOG_FRAGMENT_TAG
                        )
                    } else {
                        // If 3DS authentication not required, handle the result
                        val result = apiResult.toJudoPaymentResult(resources)
                        setResult(result.code, result.toIntent())
                        finish()
                    }
                }
                is JudoApiCallResult.Failure -> {
                    val result = apiResult.toJudoPaymentResult(resources)
                    setResult(result.code, result.toIntent())
                    finish()
                }
            }
        }
    })

To test Android transactions in the sandbox environment:

You have flexibility on how the payment experience looks to the consumer.

The UiConfiguration object allows you to:

To create the UIConfiguration object:

import com.judokit.android.UIConfiguration

val uiConfiguration = UIConfiguration.Builder()
                        .setAvsEnabled(true)
                        .setShouldPaymentMethodsDisplayAmount(true)
                        .setShouldPaymentMethodsVerifySecurityCode(true)
                        .setShouldPaymentButtonDisplayAmount(true)
                        .build()

1. Call setUIConfiguration on the Judo builder

2. Pass the uiConfiguration object:

val judo = Judo.Builder(PaymentWidgetType.PAYMENT_METHODS)
            ...
            .setUIConfiguration(uiConfiguration)
            .build()

You can also set the primary account details to be sent with the transaction.

To set the primary account details:

1. Call the setPrimaryAccountDetails on the Judo builder:

val primaryAccountDetails = PrimaryAccountDetails.Builder()
                              .setName("example-name")
                              .setAccountNumber("example-account-number")
                              .setDataOfBirth("example-date")
                              .setPostCode("example-postcode")
                              .build()

val judo = Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
            ...
            .setPrimaryAccountDetails(primaryAccountDetails)
            .build()

You can select the card networks you want to support. To select the supported card networks:

For the purpose of this exercise, Visa and MasterCard are selected as the supported card networks:

val networks = arrayOf(CardNetwork.VISA, CardNetwork.MASTERCARD)

val judo = Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
            ...
            .setSupportedCardNetworks(networks)
            .build()

Card Network Options:

To send additional card address details with the transaction:

1. Add the setAddress call on the Judo builder object:

al address = Address.Builder()
                    .setLine1("line1")
                    .setLine2("line2")
                    .setLine3("line3")
                    .setPostCode("my-postcode")
                    .setTown("town")
                    .setCountryCode("GB")
                    .build()

2. Call setAddress on the Judo builder:

val judo = Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
                    ...
                    .setAddress(address)
                    .build()

By default, all payment methods are displayed in the Payments Widget (as long as the required parameters are set). However, you can select the payment methods you want to support.

To select the supported payment methods:

val paymentMethods = arrayOf(
  PaymentMethod.CARD,
  PaymentMethod.GOOGLE_PAY,
  PaymentMethod.IDEAL
)

val judo = Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
            ...
            .setPaymentMethods(paymentMethods)
            .build()

You can add the SCAN CARD button when the consumer selects Pay with Card.

To add the Scan Card library:

An example of how your build.gradle might look:

android {
    ...
}

dependencies {
    ...
    implementation 'cards.pay:paycardsrecognizer:1.1.0'
    ...
}

To set up the Payments Widget for Android:

1. Change the PaymentWidgetType to either:

For example:

val judo = Judo.Builder(PaymentWidgetType.PAYMENT_METHODS)
            .setApiToken("my-token")
            .setApiSecret("my-secret")
            .setIsSandboxed(true)
            .setJudoId("my-judo-id")
            .setAmount(amount)
            .setReference(reference)
            .setGooglePayConfiguration(googlePayConfiguration)
            .build()

2. Start the Judo Activity:

val intent = Intent(this, JudoActivity::class.java);
intent.putExtra(Judo.JUDO_OPTIONS, judo);
startActivityForResult(intent, PAYMENT_REQUEST_CODE);

You have the flexibility of creating your own styling and colour values:

For a more detailed explanation on:

PayByBankApp enables consumers to use bank transfers to easily pay for goods and services online.

For more details on using the PayByBankApp as an alternative payment method, see:

To add the Pay by Bank button:

1. Insert the button in the layout file:

<com.judokit.android.ui.common.PayByBankButton
        android:id="@+id/payByBankButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

2. Set OnClickListener to the PayByBankApp button

payByBankButton.setOnClickListener {
            val intent = Intent(this, JudoActivity::class.java)
            intent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
        }

3. Enable the PayByBankApp in the Payment Selector Screen:

val amount = Amount.Builder()
            .setAmount("1")
            .setCurrency(Currency.GBP)
            .build()
            
Judo.Builder(PaymentWidgetType.PAYMENT_METHODS)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Start JudoActivity with the JudoConfiguration object:

val intent = Intent(this, JudoActivity::class.java)
            intent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)

The PayByBankApp Button is displayed:

iDEAL enables consumers to easily pay online for goods and services in the Netherlands.

For more details using iDEAL as an alternative payment method, see:

To add iDEAL support to your Payments Widget, set:

The judoId parameter can be set by calling setJudoId on the Judo builder.

An example of a valid iDEAL configuration:

val judo = Judo.Builder(PaymentWidgetType.PAYMENT_METHODS)
            ...
            .setJudoId("my-judo-id")
            .setCurrency("EUR")
            .build()

Once the currency and judoId are set, iDEAL will be available as a payment method in the Payments Widget.