Android

UI Configuration

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

The UiConfiguration object allows you to:

• Enable | disable the Address Verification Service 

• Show | hide the amount in the Payments Widget

• Enable | disable consumers entering the CV2 code

• Show | hide the amount in the payment button

• Enable | disable asking the consumer for their cardholder name

• Enable | disable asking the consumer for their billing information

import com.judopay.judokit.android.UIConfiguration

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

1. Call setUIConfiguration on the Judo builder

2. Pass the uiConfiguration object:

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

It is mandatory for merchants who have an MCC code of 6012 to submit additional Information about the primary account holder in primaryAccountDetails for payment pre-authorisation.

Primary Account Details

To set the primary account details when using an alternative payment method, see Adding Payment Methods.

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")
                              .setDateOfBirth("example-date")
                              .setPostCode("example-postcode")
                              .build()

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

Supported Card Networks

You can select the card networks you want to support. 

To select the supported card networks:

1. Set the setSupportedCardNetworks on the Judo builder with an array of CardNetwork values.

   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:

Default Payment Methods

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:

1. Call the setPaymentMethods on the Judo builder

2. Pass an array of PaymentMethod enum values:

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

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

The order you add the payment methods to the array is the order they will be displayed on screen.

Payments Widget

To set up the Payments Widget for Android:

1. Change the PaymentWidgetType to either:

1. PAYMENT_METHODS or, 

2. PRE_AUTH_PAYMENT_METHODS

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_OPTIONS, judo);
startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE);

Styling

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

• Override the styles.xml properties

  • to provide your own styling

• Override the colors.xml properties

  • to provide your own colour values

For a more detailed explanation on:

• Styles and Themes: See the Android Developer Guide.

• Brand Guidelines: See the Google Pay™ Brand Guidelines.

Configuring Google Pay™ for Android

Prerequisites

• You have set up your Google Pay™ payments profile.

  • For more details, see Create a Payments Profile..

• You have imported the following models:

import com.judopay.judokit.android.model.googlepay.GooglePayAddressFormat
import com.judopay.judokit.android.model.googlepay.GooglePayBillingAddressParameters
import com.judopay.judokit.android.model.GooglePayConfiguration
import com.judopay.judokit.android.model.googlepay.GooglePayEnvironment
import com.judopay.judokit.android.model.googlepay.GooglePayShippingAddressParameters

Creating the Google Pay™ Configuration

To create the Google Pay™ configuration:

1. Set the required properties using the prerequisite imported models.

2. Set some additional optional properties to customise Google Pay™:

val billingAddressParams = GooglePayBillingAddressParameters( 
    format = GooglePayAddressFormat.MIN, 
    phoneNumberRequired = true
    )

val shippingAddressParams = GooglePayShippingAddressParameters( 
    phoneNumberRequired = true
    )
val googlePayConfiguration = GooglePayConfiguration.Builder() 
    .setTransactionCountryCode("GB") 
    .setEnvironment(GooglePayEnvironment.TEST) 
    .setIsEmailRequired(true) 
    .setIsBillingAddressRequired(true) 
    .setBillingAddressParameters(billingAddressParams) 
    .setIsShippingAddressRequired(true) 
    .setShippingAddressParameters(shippingAddressParams) 
.build()

setTransactionCountryCode

Required

setEnvironment

Required

setIsEmailRequired

Optional

setIsBillingAddressRequired

Optional

setBillingAddressParameters

Optional

SetIsShippingAddressRequired

Optional

setShippingAddressParameters

Optional

Although setting the billing and shipping parameters is optional, they must be provided if the billing and shipping requirements are set to true.

Making a Google Pay™ Transaction

Prerequisite

You have set up the GooglePayConfiguration.

To make a Google Pay™ transaction:

1. Add the setGooglePayConfiguration method to the Judo builder

2. Set the PaymentWidgetType to: 

   • GOOGLE_PAY

3. Start the Judo activity:

val judo = Judo.Builder(PaymentWidgetType.GOOGLE_PAY)
    ... 
    .setGooglePayConfiguration(googlePayConfiguration) 
    .build()
    
val intent = Intent(this, JudoActivity::class.java);
intent.putExtra(JUDO_OPTIONS, judo);
startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE);

To make a Google Pay™ pre-auth request:

1. Add the setGooglePayConfiguration method to the Judo builder

2. Set the PaymentWidgetType to: 

   • PRE_AUTH_GOOGLE_PAY

3. Start the Judo activity:

val judo = Judo.Builder(PaymentWidgetType.PRE_AUTH_GOOGLE_PAY)
    ... 
    .setGooglePayConfiguration(googlePayConfiguration) 
    .build()
    
val intent = Intent(this, JudoActivity::class.java);
intent.putExtra(JUDO_OPTIONS, judo);
startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE);

To add the PayByBankApp button

1. Insert the button in the layout file:

<com.judopay.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

   The JudoActivity will start and pass the result to merchant:

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:

   • Build the Judo configuration object:

     • Set the payment widget type to:

       • PaymentWidgetType.PAYMENT_METHODS

     • Set the currency:

       • GBP

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)

For the PayByBankApp button to appear in the Payments Widget, a banking app must already be installed.

The PayByBankApp Button is displayed:

To display the PayByBankApp as a Payment Method for Android:

1. Add the intent-filter to the AndroidManifest.xml file.

   This registers the deep link URL:

<activity
  android:name=".MainActivity"
  android:launchMode="singleTask">
  <intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

        <data
           android:scheme="your"
           android:host="scheme" />
  </intent-filter>
</activity>

2. Create the Judo  object:

   • Set PaymentWidgetType to:

     • PAY_BY_BANK_APP, or

     • PAYMENT_METHODS

       If using the payments widget.

   • Set currency:

     • GBP

3. Create the PBBAConfiguration object:

   • Set deepLinkScheme to the defined scheme in the AndroidManifest.xml file:

 val pbbaConfiguration = PBBAConfiguration.Builder()
        .setDeepLinkScheme("your://scheme")
        .build()
Judo.Builder(PaymentWidgetType.PAY_BY_BANK_APP)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Override the onNewIntent method to catch the deeplink URL

   • Add the deepLinkURL to the PBBAConfiguration object

   • Start JudoActivity with the desired payment widget type

   • Add the same logic in onCreate

 override fun onNewIntent(intent: Intent?) {
        checkForDeepLink(intent)
        super.onNewIntent(intent)
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        checkForDeepLink()
        ...
    }
    
    private fun checkForDeepLink(intent: Intent? = this.intent) {
        val uri = intent?.data
        val newIntent = Intent(this, JudoActivity::class.java)
        if (uri.contains("your://scheme")) {  
            val newPbbaConfig = pbbaConfiguration.newBuilder()
                .setDeepLinkURL(uri)
                .build()
            val judo = getJudo(PaymentWidgetType.PAY_BY_BANK_APP).newBuilder()
                .setPBBAConfiguration(newPbbaConfig)
                .build()
            newIntent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(newIntent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
        }
    }
    
    private fun getJudo(widgetType: PaymentWidgetType): Judo {
        return Judo.Builder(widgetType)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

5. To catch the first response, create a broadcastReceiver:

private val broadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
    val result = intent?.getParcelableExtra<JudoResult>(PBBA_RESULT)
        // Handle result
    }
}

6. Register the defined receiver in onCreate:

LocalBroadcastManager.getInstance(this).registerReceiver(
    orderIdReceiver,
    IntentFilter(BR_PBBA_RESULT)
)

7. Catch the result in the onActivityResult method:

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

     if (requestCode == JUDO_PAYMENT_WIDGET_REQUEST_CODE) {
       when (resultCode) {
         PAYMENT_SUCCESS -> {
         val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
             //Process successful payment
              }
         PAYMENT_CANCELLED -> {
         val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
            //Process cancelled payment
              } 
         PAYMENT_ERROR -> {
         val error = data?.getParcelableExtra<JudoError>(JUDO_ERROR)
            //Process unsuccessful payment
              }    
          }
      }
}

Not using the Mobile SDK Payments Widget?

To Integrate directly to your app:

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. Add intent-filter to the AndroidManifest.xml file.

   This will register the deep link URL:

activity
 android:name=".MainActivity"
 android:launchMode="singleTask">
 <intent-filter>
 <action android:name="android.intent.action.VIEW" />

 <category android:name="android.intent.category.DEFAULT" />
 <category android:name="android.intent.category.BROWSABLE" />

 <data
   android:scheme="your"
   android:host="scheme" />
 </intent-filter>
 </activity>

3. Create the Judo object:

   • Set the PaymentWidgetType to PAY_BY_BANK_APP

   • Create the PBBAConfiguration object

   • Set deepLinkScheme to the defined scheme in the AndroidManifest.xml file:

 val pbbaConfiguration = PBBAConfiguration.Builder()
        .setDeepLinkScheme("your://scheme")
        .build()
Judo.Builder(PaymentWidgetType.PAY_BY_BANK_APP)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

4. Override the onNewIntent method to catch the deeplink URL:

   • Add the deepLinkURL to the PBBAConfiguration object

   • Start JudoActivity with the desired payment widget type

   • Add the same logic in onCreate

 override fun onNewIntent(intent: Intent?) {
        checkForDeepLink(intent)
        super.onNewIntent(intent)
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        checkForDeepLink()
        ...
    }
    
    private fun checkForDeepLink(intent: Intent? = this.intent) {
        val uri = intent?.data
        val newIntent = Intent(this, JudoActivity::class.java)
        if (uri.contains("your://scheme")) {  
            val newPbbaConfig = pbbaConfiguration.newBuilder()
                .setDeepLinkURL(uri)
                .build()
            val judo = getJudo(PaymentWidgetType.PAY_BY_BANK_APP).newBuilder()
                .setPBBAConfiguration(newPbbaConfig)
                .build()
            newIntent.putExtra(JUDO_OPTIONS, judo)
            startActivityForResult(newIntent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
        }
    }
    
    private fun getJudo(widgetType: PaymentWidgetType): Judo {
        return Judo.Builder(widgetType)
            .setJudoId(judoId)
            .setApiToken(token)
            .setApiSecret(secret)
            .setAmount(amount)
            .setReference(reference)
            .setIsSandboxed(isSandboxed)
            .setSupportedCardNetworks(networks)
            .setPaymentMethods(paymentMethods)
            .setUiConfiguration(uiConfiguration)
            .setGooglePayConfiguration(googlePayConfiguration)
            .setPBBAConfiguration(pbbaConfiguration)
            .build()

5. To catch the first response, create a broadcastReceiver:

private val broadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
    val result = intent?.getParcelableExtra<JudoResult>(PBBA_RESULT)
        // Handle result
    }
}

6. Register the defined receiver in onCreate:

LocalBroadcastManager.getInstance(this).registerReceiver(
    orderIdReceiver,
    IntentFilter(BR_PBBA_RESULT)
)

7. Set OnClickListener to the previously defined PayByBankApp button

   JudoActivity will start and pass the result to merchant:
   

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

8. Catch the result in the onActivityResult method:

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

    if (requestCode == JUDO_PAYMENT_WIDGET_REQUEST_CODE) {
       when (resultCode) {
       PAYMENT_SUCCESS -> {
       val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
           //Process successful payment
             }
       PAYMENT_CANCELLED -> {
       val result = data?.getParcelableExtra<JudoResult>(JUDO_RESULT)
           //Process cancelled payment
             } 
       PAYMENT_ERROR -> {
       val error = data?.getParcelableExtra<JudoError>(JUDO_ERROR)
           //Process unsuccessful payment
                }    
            }
        }
    }

Displaying iDEAL as a Payment Method for Android

To add iDEAL support to your Payments Widget, set:

1. The currency code to EUR (Euro)

2. The JudoId

The 

judoId

setJudoId

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.